blob: b57d0cb635b8ac0c7aeb89c5623e5358a4afd161 [file] [log] [blame]
unknown088160a2019-05-23 17:43:13 -06001/*
Aaron Hagand1a61212021-12-22 11:53:49 -05002 * Copyright (c) 2015-2022 The Khronos Group Inc.
3 * Copyright (c) 2015-2022 Valve Corporation
4 * Copyright (c) 2015-2022 LunarG, Inc.
5 * Copyright (c) 2015-2022 Google, Inc.
6 * Modifications Copyright (C) 2022 Advanced Micro Devices, Inc. All rights reserved.
unknown088160a2019-05-23 17:43:13 -06007 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Author: Chia-I Wu <olvaffe@gmail.com>
15 * Author: Chris Forbes <chrisf@ijw.co.nz>
16 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
17 * Author: Mark Lobodzinski <mark@lunarg.com>
18 * Author: Mike Stroyan <mike@LunarG.com>
19 * Author: Tobin Ehlis <tobine@google.com>
20 * Author: Tony Barbour <tony@LunarG.com>
21 * Author: Cody Northrop <cnorthrop@google.com>
22 * Author: Dave Houlton <daveh@lunarg.com>
23 * Author: Jeremy Kniager <jeremyk@lunarg.com>
24 * Author: Shannon McPherson <shannon@lunarg.com>
25 * Author: John Zulauf <jzulauf@lunarg.com>
Tobias Hector04f2ab22020-12-01 10:59:33 +000026 * Author: Tobias Hector <tobias.hector@amd.com>
unknown088160a2019-05-23 17:43:13 -060027 */
28
29#include "cast_utils.h"
30#include "layer_validation_tests.h"
31
32TEST_F(VkLayerTest, InvalidCommandPoolConsistency) {
33 TEST_DESCRIPTION("Allocate command buffers from one command pool and attempt to delete them from another.");
34
Mark Lobodzinski20310782020-02-28 14:25:17 -070035 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkFreeCommandBuffers-pCommandBuffers-parent");
unknown088160a2019-05-23 17:43:13 -060036
37 ASSERT_NO_FATAL_FAILURE(Init());
38 VkCommandPool command_pool_one;
39 VkCommandPool command_pool_two;
40
sfricke-samsung1c61f192021-12-31 01:53:03 -060041 VkCommandPoolCreateInfo pool_create_info = LvlInitStruct<VkCommandPoolCreateInfo>();
unknown088160a2019-05-23 17:43:13 -060042 pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
43 pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
44
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -060045 vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_one);
unknown088160a2019-05-23 17:43:13 -060046
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -060047 vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_two);
unknown088160a2019-05-23 17:43:13 -060048
49 VkCommandBuffer cb;
sfricke-samsung1c61f192021-12-31 01:53:03 -060050 VkCommandBufferAllocateInfo command_buffer_allocate_info = LvlInitStruct<VkCommandBufferAllocateInfo>();
unknown088160a2019-05-23 17:43:13 -060051 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);
sfricke-samsung1c61f192021-12-31 01:53:03 -0600134 VkImageMemoryBarrier img_barrier = LvlInitStruct<VkImageMemoryBarrier>();
unknown088160a2019-05-23 17:43:13 -0600135 img_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
136 img_barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
137 img_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
138 img_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
139 img_barrier.image = image2.handle(); // Image mis-matches with FB image
140 img_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
141 img_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
142 img_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
143 img_barrier.subresourceRange.baseArrayLayer = 0;
144 img_barrier.subresourceRange.baseMipLevel = 0;
145 img_barrier.subresourceRange.layerCount = 1;
146 img_barrier.subresourceRange.levelCount = 1;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600147 vk::CmdPipelineBarrier(secondary.handle(), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
148 VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, &img_barrier);
unknown088160a2019-05-23 17:43:13 -0600149 secondary.end();
150
Shannon McPherson93970b12020-06-12 14:34:35 -0600151 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-image-04073");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600152 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600153 m_errorMonitor->VerifyFound();
154
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600155 vk::DestroyFramebuffer(m_device->device(), fb, nullptr);
156 vk::DestroyRenderPass(m_device->device(), rp, nullptr);
unknown088160a2019-05-23 17:43:13 -0600157}
158
159TEST_F(VkLayerTest, DynamicDepthBiasNotBound) {
160 TEST_DESCRIPTION(
161 "Run a simple draw calls to validate failure when Depth Bias dynamic state is required but not correctly bound.");
162
163 ASSERT_NO_FATAL_FAILURE(Init());
164 // Dynamic depth bias
Mark Lobodzinski20310782020-02-28 14:25:17 -0700165 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bias state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600166 VKTriangleTest(BsoFailDepthBias);
167 m_errorMonitor->VerifyFound();
168}
169
170TEST_F(VkLayerTest, DynamicLineWidthNotBound) {
171 TEST_DESCRIPTION(
172 "Run a simple draw calls to validate failure when Line Width dynamic state is required but not correctly bound.");
173
174 ASSERT_NO_FATAL_FAILURE(Init());
175 // Dynamic line width
Mark Lobodzinski20310782020-02-28 14:25:17 -0700176 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line width state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600177 VKTriangleTest(BsoFailLineWidth);
178 m_errorMonitor->VerifyFound();
179}
180
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500181TEST_F(VkLayerTest, DynamicLineStippleNotBound) {
182 TEST_DESCRIPTION(
183 "Run a simple draw calls to validate failure when Line Stipple dynamic state is required but not correctly bound.");
184
sjfricked8e01c52022-07-06 14:09:04 +0900185 AddRequiredExtensions(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -0700186 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sjfricked8e01c52022-07-06 14:09:04 +0900187 if (!AreRequiredExtensionsEnabled()) {
188 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500189 }
190
191 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600192 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500193 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
194
Mark Lobodzinski07d0a612020-12-30 15:42:31 -0700195 auto line_rasterization_features = LvlInitStruct<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
196 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&line_rasterization_features);
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500197 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
198
199 if (!line_rasterization_features.stippledBresenhamLines || !line_rasterization_features.bresenhamLines) {
200 printf("%sStipple Bresenham lines not supported; skipped.\n", kSkipPrefix);
201 return;
202 }
203
204 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
205
Mark Lobodzinski20310782020-02-28 14:25:17 -0700206 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line stipple state not set for this command buffer");
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500207 VKTriangleTest(BsoFailLineStipple);
208 m_errorMonitor->VerifyFound();
209}
210
unknown088160a2019-05-23 17:43:13 -0600211TEST_F(VkLayerTest, DynamicViewportNotBound) {
212 TEST_DESCRIPTION(
213 "Run a simple draw calls to validate failure when Viewport dynamic state is required but not correctly bound.");
214
215 ASSERT_NO_FATAL_FAILURE(Init());
216 // Dynamic viewport state
Mark Lobodzinski20310782020-02-28 14:25:17 -0700217 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600218 "Dynamic viewport(s) 0 are used by pipeline state object, but were not provided");
219 VKTriangleTest(BsoFailViewport);
220 m_errorMonitor->VerifyFound();
221}
222
223TEST_F(VkLayerTest, DynamicScissorNotBound) {
224 TEST_DESCRIPTION("Run a simple draw calls to validate failure when Scissor dynamic state is required but not correctly bound.");
225
226 ASSERT_NO_FATAL_FAILURE(Init());
227 // Dynamic scissor state
Mark Lobodzinski20310782020-02-28 14:25:17 -0700228 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600229 "Dynamic scissor(s) 0 are used by pipeline state object, but were not provided");
230 VKTriangleTest(BsoFailScissor);
231 m_errorMonitor->VerifyFound();
232}
233
234TEST_F(VkLayerTest, DynamicBlendConstantsNotBound) {
235 TEST_DESCRIPTION(
236 "Run a simple draw calls to validate failure when Blend Constants dynamic state is required but not correctly bound.");
237
238 ASSERT_NO_FATAL_FAILURE(Init());
239 // Dynamic blend constant state
Mark Lobodzinski20310782020-02-28 14:25:17 -0700240 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic blend constants state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600241 VKTriangleTest(BsoFailBlend);
242 m_errorMonitor->VerifyFound();
243}
244
245TEST_F(VkLayerTest, DynamicDepthBoundsNotBound) {
246 TEST_DESCRIPTION(
247 "Run a simple draw calls to validate failure when Depth Bounds dynamic state is required but not correctly bound.");
248
249 ASSERT_NO_FATAL_FAILURE(Init());
250 if (!m_device->phy().features().depthBounds) {
251 printf("%s Device does not support depthBounds test; skipped.\n", kSkipPrefix);
252 return;
253 }
254 // Dynamic depth bounds
Mark Lobodzinski20310782020-02-28 14:25:17 -0700255 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bounds state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600256 VKTriangleTest(BsoFailDepthBounds);
257 m_errorMonitor->VerifyFound();
258}
259
260TEST_F(VkLayerTest, DynamicStencilReadNotBound) {
261 TEST_DESCRIPTION(
262 "Run a simple draw calls to validate failure when Stencil Read dynamic state is required but not correctly bound.");
263
264 ASSERT_NO_FATAL_FAILURE(Init());
265 // Dynamic stencil read mask
Mark Lobodzinski20310782020-02-28 14:25:17 -0700266 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil read mask state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600267 VKTriangleTest(BsoFailStencilReadMask);
268 m_errorMonitor->VerifyFound();
269}
270
271TEST_F(VkLayerTest, DynamicStencilWriteNotBound) {
272 TEST_DESCRIPTION(
273 "Run a simple draw calls to validate failure when Stencil Write dynamic state is required but not correctly bound.");
274
275 ASSERT_NO_FATAL_FAILURE(Init());
276 // Dynamic stencil write mask
Mark Lobodzinski20310782020-02-28 14:25:17 -0700277 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil write mask state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600278 VKTriangleTest(BsoFailStencilWriteMask);
279 m_errorMonitor->VerifyFound();
280}
281
282TEST_F(VkLayerTest, DynamicStencilRefNotBound) {
283 TEST_DESCRIPTION(
284 "Run a simple draw calls to validate failure when Stencil Ref dynamic state is required but not correctly bound.");
285
286 ASSERT_NO_FATAL_FAILURE(Init());
287 // Dynamic stencil reference
Mark Lobodzinski20310782020-02-28 14:25:17 -0700288 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil reference state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600289 VKTriangleTest(BsoFailStencilReference);
290 m_errorMonitor->VerifyFound();
291}
292
293TEST_F(VkLayerTest, IndexBufferNotBound) {
294 TEST_DESCRIPTION("Run an indexed draw call without an index buffer bound.");
295
296 ASSERT_NO_FATAL_FAILURE(Init());
Mark Lobodzinski20310782020-02-28 14:25:17 -0700297 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Index buffer object not bound to this command buffer when Indexed ");
unknown088160a2019-05-23 17:43:13 -0600298 VKTriangleTest(BsoFailIndexBuffer);
299 m_errorMonitor->VerifyFound();
300}
301
302TEST_F(VkLayerTest, IndexBufferBadSize) {
303 TEST_DESCRIPTION("Run indexed draw call with bad index buffer size.");
304
305 ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
Tony-LunarG4490de42021-06-21 15:49:19 -0600306 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed(): index size ");
unknown088160a2019-05-23 17:43:13 -0600307 VKTriangleTest(BsoFailIndexBufferBadSize);
308 m_errorMonitor->VerifyFound();
309}
310
311TEST_F(VkLayerTest, IndexBufferBadOffset) {
312 TEST_DESCRIPTION("Run indexed draw call with bad index buffer offset.");
313
314 ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
Tony-LunarG4490de42021-06-21 15:49:19 -0600315 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed(): index size ");
unknown088160a2019-05-23 17:43:13 -0600316 VKTriangleTest(BsoFailIndexBufferBadOffset);
317 m_errorMonitor->VerifyFound();
318}
319
320TEST_F(VkLayerTest, IndexBufferBadBindSize) {
321 TEST_DESCRIPTION("Run bind index buffer with a size greater than the index buffer.");
322
323 ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
Tony-LunarG4490de42021-06-21 15:49:19 -0600324 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed(): index size ");
unknown088160a2019-05-23 17:43:13 -0600325 VKTriangleTest(BsoFailIndexBufferBadMapSize);
326 m_errorMonitor->VerifyFound();
327}
328
329TEST_F(VkLayerTest, IndexBufferBadBindOffset) {
330 TEST_DESCRIPTION("Run bind index buffer with an offset greater than the size of the index buffer.");
331
332 ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
Tony-LunarG4490de42021-06-21 15:49:19 -0600333 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed(): index size ");
unknown088160a2019-05-23 17:43:13 -0600334 VKTriangleTest(BsoFailIndexBufferBadMapOffset);
335 m_errorMonitor->VerifyFound();
336}
337
338TEST_F(VkLayerTest, MissingClearAttachment) {
339 TEST_DESCRIPTION("Points to a wrong colorAttachment index in a VkClearAttachment structure passed to vkCmdClearAttachments");
340 ASSERT_NO_FATAL_FAILURE(Init());
Mark Lobodzinski20310782020-02-28 14:25:17 -0700341 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-aspectMask-02501");
unknown088160a2019-05-23 17:43:13 -0600342
343 VKTriangleTest(BsoFailCmdClearAttachments);
344 m_errorMonitor->VerifyFound();
345}
346
Mark Lobodzinskicd0204c2019-11-11 16:59:18 -0700347TEST_F(VkLayerTest, SecondaryCommandbufferAsPrimary) {
348 TEST_DESCRIPTION("Create a secondary command buffer and pass it to QueueSubmit.");
Mark Lobodzinski20310782020-02-28 14:25:17 -0700349 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pCommandBuffers-00075");
Mark Lobodzinskicd0204c2019-11-11 16:59:18 -0700350
351 ASSERT_NO_FATAL_FAILURE(Init());
352
353 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
354 secondary.begin();
355 secondary.ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color);
356 secondary.end();
357
sfricke-samsung1c61f192021-12-31 01:53:03 -0600358 VkSubmitInfo submit_info = LvlInitStruct<VkSubmitInfo>();
Mark Lobodzinskicd0204c2019-11-11 16:59:18 -0700359 submit_info.waitSemaphoreCount = 0;
360 submit_info.pWaitSemaphores = NULL;
361 submit_info.pWaitDstStageMask = NULL;
362 submit_info.commandBufferCount = 1;
363 submit_info.pCommandBuffers = &secondary.handle();
364 submit_info.signalSemaphoreCount = 0;
365 submit_info.pSignalSemaphores = NULL;
366
367 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
368 m_errorMonitor->VerifyFound();
369}
370
Jeremy Gebben1db6edc2021-02-17 15:28:40 -0700371TEST_F(VkLayerTest, Sync2SecondaryCommandbufferAsPrimary) {
372 TEST_DESCRIPTION("Create a secondary command buffer and pass it to QueueSubmit2KHR.");
373 SetTargetApiVersion(VK_API_VERSION_1_2);
374 ASSERT_NO_FATAL_FAILURE(InitFramework());
375 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) {
376 m_device_extension_names.push_back(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
377 } else {
378 printf("%s Synchronization2 not supported, skipping test\n", kSkipPrefix);
379 return;
380 }
381
382 if (!CheckSynchronization2SupportAndInitState(this)) {
383 printf("%s Synchronization2 not supported, skipping test\n", kSkipPrefix);
384 return;
385 }
386 auto fpQueueSubmit2KHR = (PFN_vkQueueSubmit2KHR)vk::GetDeviceProcAddr(m_device->device(), "vkQueueSubmit2KHR");
Tony-LunarG279601c2021-11-16 10:50:51 -0700387 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCommandBufferSubmitInfo-commandBuffer-03890");
Jeremy Gebben1db6edc2021-02-17 15:28:40 -0700388
389 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
390 secondary.begin();
391 secondary.ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color);
392 secondary.end();
393
394 auto cb_info = lvl_init_struct<VkCommandBufferSubmitInfoKHR>();
395 cb_info.commandBuffer = secondary.handle();
396
397 auto submit_info = lvl_init_struct<VkSubmitInfo2KHR>();
398 submit_info.commandBufferInfoCount = 1;
399 submit_info.pCommandBufferInfos = &cb_info;
400
401 fpQueueSubmit2KHR(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
402 m_errorMonitor->VerifyFound();
403}
404
unknown088160a2019-05-23 17:43:13 -0600405TEST_F(VkLayerTest, CommandBufferTwoSubmits) {
Mark Lobodzinski20310782020-02-28 14:25:17 -0700406 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600407 "was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted");
408
409 ASSERT_NO_FATAL_FAILURE(Init());
410 ASSERT_NO_FATAL_FAILURE(InitViewport());
411 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
412
413 // We luck out b/c by default the framework creates CB w/ the
414 // VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set
415 m_commandBuffer->begin();
416 m_commandBuffer->ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color);
417 m_commandBuffer->end();
418
419 // Bypass framework since it does the waits automatically
420 VkResult err = VK_SUCCESS;
sfricke-samsung1c61f192021-12-31 01:53:03 -0600421 VkSubmitInfo submit_info = LvlInitStruct<VkSubmitInfo>();
unknown088160a2019-05-23 17:43:13 -0600422 submit_info.waitSemaphoreCount = 0;
423 submit_info.pWaitSemaphores = NULL;
424 submit_info.pWaitDstStageMask = NULL;
425 submit_info.commandBufferCount = 1;
426 submit_info.pCommandBuffers = &m_commandBuffer->handle();
427 submit_info.signalSemaphoreCount = 0;
428 submit_info.pSignalSemaphores = NULL;
429
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600430 err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -0600431 ASSERT_VK_SUCCESS(err);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600432 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -0600433
434 // Cause validation error by re-submitting cmd buffer that should only be
435 // submitted once
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600436 err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
437 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -0600438
439 m_errorMonitor->VerifyFound();
440}
441
Jeremy Gebben1db6edc2021-02-17 15:28:40 -0700442TEST_F(VkLayerTest, Sync2CommandBufferTwoSubmits) {
443 SetTargetApiVersion(VK_API_VERSION_1_2);
444 ASSERT_NO_FATAL_FAILURE(InitFramework());
445 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) {
446 m_device_extension_names.push_back(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
447 } else {
448 printf("%s Synchronization2 not supported, skipping test\n", kSkipPrefix);
449 return;
450 }
451
452 if (!CheckSynchronization2SupportAndInitState(this)) {
453 printf("%s Synchronization2 not supported, skipping test\n", kSkipPrefix);
454 return;
455 }
456 auto fpQueueSubmit2KHR = (PFN_vkQueueSubmit2KHR)vk::GetDeviceProcAddr(m_device->device(), "vkQueueSubmit2KHR");
457
458 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
459 "was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted");
460 ASSERT_NO_FATAL_FAILURE(InitViewport());
461 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
462
463 // We luck out b/c by default the framework creates CB w/ the
464 // VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set
465 m_commandBuffer->begin();
466 m_commandBuffer->ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color);
467 m_commandBuffer->end();
468
469 // Bypass framework since it does the waits automatically
470 VkResult err = VK_SUCCESS;
471 auto cb_info = lvl_init_struct<VkCommandBufferSubmitInfoKHR>();
472 cb_info.commandBuffer = m_commandBuffer->handle();
473
474 auto submit_info = lvl_init_struct<VkSubmitInfo2KHR>();
475 submit_info.commandBufferInfoCount = 1;
476 submit_info.pCommandBufferInfos = &cb_info;
477
478 err = fpQueueSubmit2KHR(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
479 ASSERT_VK_SUCCESS(err);
480 vk::QueueWaitIdle(m_device->m_queue);
481
482 // Cause validation error by re-submitting cmd buffer that should only be
483 // submitted once
484 err = fpQueueSubmit2KHR(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
485 vk::QueueWaitIdle(m_device->m_queue);
486
487 m_errorMonitor->VerifyFound();
488}
489
unknown088160a2019-05-23 17:43:13 -0600490TEST_F(VkLayerTest, InvalidPushConstants) {
491 ASSERT_NO_FATAL_FAILURE(Init());
492 ASSERT_NO_FATAL_FAILURE(InitViewport());
493 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
494
495 VkPipelineLayout pipeline_layout;
496 VkPushConstantRange pc_range = {};
sfricke-samsung1c61f192021-12-31 01:53:03 -0600497 VkPipelineLayoutCreateInfo pipeline_layout_ci = LvlInitStruct<VkPipelineLayoutCreateInfo>();
unknown088160a2019-05-23 17:43:13 -0600498 pipeline_layout_ci.pushConstantRangeCount = 1;
499 pipeline_layout_ci.pPushConstantRanges = &pc_range;
500
501 //
502 // Check for invalid push constant ranges in pipeline layouts.
503 //
504 struct PipelineLayoutTestCase {
505 VkPushConstantRange const range;
506 char const *msg;
507 };
508
509 const uint32_t too_big = m_device->props.limits.maxPushConstantsSize + 0x4;
510 const std::array<PipelineLayoutTestCase, 10> range_tests = {{
sfricke-samsung51303fb2021-05-09 19:09:13 -0700511 {{VK_SHADER_STAGE_VERTEX_BIT, 0, 0}, "VUID-VkPushConstantRange-size-00296"},
512 {{VK_SHADER_STAGE_VERTEX_BIT, 0, 1}, "VUID-VkPushConstantRange-size-00297"},
513 {{VK_SHADER_STAGE_VERTEX_BIT, 4, 1}, "VUID-VkPushConstantRange-size-00297"},
514 {{VK_SHADER_STAGE_VERTEX_BIT, 4, 0}, "VUID-VkPushConstantRange-size-00296"},
515 {{VK_SHADER_STAGE_VERTEX_BIT, 1, 4}, "VUID-VkPushConstantRange-offset-00295"},
516 {{VK_SHADER_STAGE_VERTEX_BIT, 0, too_big}, "VUID-VkPushConstantRange-size-00298"},
517 {{VK_SHADER_STAGE_VERTEX_BIT, too_big, too_big}, "VUID-VkPushConstantRange-offset-00294"},
518 {{VK_SHADER_STAGE_VERTEX_BIT, too_big, 4}, "VUID-VkPushConstantRange-offset-00294"},
519 {{VK_SHADER_STAGE_VERTEX_BIT, 0xFFFFFFF0, 0x00000020}, "VUID-VkPushConstantRange-offset-00294"},
520 {{VK_SHADER_STAGE_VERTEX_BIT, 0x00000020, 0xFFFFFFF0}, "VUID-VkPushConstantRange-size-00298"},
unknown088160a2019-05-23 17:43:13 -0600521 }};
522
523 // Check for invalid offset and size
524 for (const auto &iter : range_tests) {
525 pc_range = iter.range;
Mark Lobodzinski20310782020-02-28 14:25:17 -0700526 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600527 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600528 m_errorMonitor->VerifyFound();
529 }
530
531 // Check for invalid stage flag
532 pc_range.offset = 0;
533 pc_range.size = 16;
534 pc_range.stageFlags = 0;
sfricke-samsung51303fb2021-05-09 19:09:13 -0700535 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkPushConstantRange-stageFlags-requiredbitmask");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600536 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600537 m_errorMonitor->VerifyFound();
538
539 // Check for duplicate stage flags in a list of push constant ranges.
540 // A shader can only have one push constant block and that block is mapped
541 // to the push constant range that has that shader's stage flag set.
542 // The shader's stage flag can only appear once in all the ranges, so the
543 // implementation can find the one and only range to map it to.
544 const uint32_t ranges_per_test = 5;
545 struct DuplicateStageFlagsTestCase {
546 VkPushConstantRange const ranges[ranges_per_test];
547 std::vector<char const *> const msg;
548 };
549 // Overlapping ranges are OK, but a stage flag can appear only once.
550 const std::array<DuplicateStageFlagsTestCase, 3> duplicate_stageFlags_tests = {
551 {
552 {{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
553 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
554 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
555 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
556 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}},
557 {
558 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 1.",
559 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 2.",
560 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.",
561 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 4.",
562 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 2.",
563 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 3.",
564 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.",
565 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.",
566 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 4.",
567 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 3 and 4.",
568 }},
569 {{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
570 {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4},
571 {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4},
572 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
573 {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}},
574 {
575 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.",
576 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.",
577 }},
578 {{{VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4},
579 {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 0, 4},
580 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
581 {VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
582 {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}},
583 {
584 "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.",
585 }},
586 },
587 };
588
589 for (const auto &iter : duplicate_stageFlags_tests) {
590 pipeline_layout_ci.pPushConstantRanges = iter.ranges;
591 pipeline_layout_ci.pushConstantRangeCount = ranges_per_test;
Mark Lobodzinski20310782020-02-28 14:25:17 -0700592 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg.begin(), iter.msg.end());
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600593 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600594 m_errorMonitor->VerifyFound();
595 }
596
597 //
598 // CmdPushConstants tests
599 //
600
601 // Setup a pipeline layout with ranges: [0,32) [16,80)
602 const std::vector<VkPushConstantRange> pc_range2 = {{VK_SHADER_STAGE_VERTEX_BIT, 16, 64},
603 {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 32}};
604 const VkPipelineLayoutObj pipeline_layout_obj(m_device, {}, pc_range2);
605
606 const uint8_t dummy_values[100] = {};
607
608 m_commandBuffer->begin();
609 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
610
611 // Check for invalid stage flag
612 // Note that VU 00996 isn't reached due to parameter validation
sfricke-samsung51303fb2021-05-09 19:09:13 -0700613 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-stageFlags-requiredbitmask");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600614 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), 0, 0, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600615 m_errorMonitor->VerifyFound();
616
617 // Positive tests for the overlapping ranges
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600618 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16,
619 dummy_values);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600620 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 32, 48, dummy_values);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600621 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
622 VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 16, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600623
624 // Wrong cmd stages for extant range
625 // No range for all cmd stages -- "VUID-vkCmdPushConstants-offset-01795" VUID-vkCmdPushConstants-offset-01795
Mark Lobodzinski20310782020-02-28 14:25:17 -0700626 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
unknown088160a2019-05-23 17:43:13 -0600627 // Missing cmd stages for found overlapping range -- "VUID-vkCmdPushConstants-offset-01796" VUID-vkCmdPushConstants-offset-01796
Mark Lobodzinski20310782020-02-28 14:25:17 -0700628 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600629 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_GEOMETRY_BIT, 0, 16,
630 dummy_values);
unknown088160a2019-05-23 17:43:13 -0600631 m_errorMonitor->VerifyFound();
632
633 // Wrong no extant range
Mark Lobodzinski20310782020-02-28 14:25:17 -0700634 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600635 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 80, 4,
636 dummy_values);
unknown088160a2019-05-23 17:43:13 -0600637 m_errorMonitor->VerifyFound();
638
639 // Wrong overlapping extent
Mark Lobodzinski20310782020-02-28 14:25:17 -0700640 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600641 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
642 VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 20, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600643 m_errorMonitor->VerifyFound();
644
645 // Wrong stage flags for valid overlapping range
Mark Lobodzinski20310782020-02-28 14:25:17 -0700646 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600647 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 16, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600648 m_errorMonitor->VerifyFound();
649
650 m_commandBuffer->EndRenderPass();
651 m_commandBuffer->end();
652}
653
654TEST_F(VkLayerTest, NoBeginCommandBuffer) {
sfricke-samsung946027b2021-04-20 22:44:36 -0700655 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkEndCommandBuffer-commandBuffer-00059");
unknown088160a2019-05-23 17:43:13 -0600656
657 ASSERT_NO_FATAL_FAILURE(Init());
658 VkCommandBufferObj commandBuffer(m_device, m_commandPool);
659 // Call EndCommandBuffer() w/o calling BeginCommandBuffer()
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600660 vk::EndCommandBuffer(commandBuffer.handle());
unknown088160a2019-05-23 17:43:13 -0600661
662 m_errorMonitor->VerifyFound();
663}
664
unknown088160a2019-05-23 17:43:13 -0600665TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedExplicitReset) {
666 ASSERT_NO_FATAL_FAILURE(Init());
667
Mark Lobodzinski20310782020-02-28 14:25:17 -0700668 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded");
unknown088160a2019-05-23 17:43:13 -0600669
670 // A pool we can reset in.
671 VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
672 VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
673
674 secondary.begin();
675 secondary.end();
676
677 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600678 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600679
680 // rerecording of secondary
681 secondary.reset(); // explicit reset here.
682 secondary.begin();
683 secondary.end();
684
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600685 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600686 m_errorMonitor->VerifyFound();
687}
688
689TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedNoReset) {
690 ASSERT_NO_FATAL_FAILURE(Init());
691
Mark Lobodzinski20310782020-02-28 14:25:17 -0700692 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded");
unknown088160a2019-05-23 17:43:13 -0600693
694 // A pool we can reset in.
695 VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
696 VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
697
698 secondary.begin();
699 secondary.end();
700
701 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600702 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600703
704 // rerecording of secondary
705 secondary.begin(); // implicit reset in begin
706 secondary.end();
707
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600708 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600709 m_errorMonitor->VerifyFound();
710}
711
712TEST_F(VkLayerTest, CascadedInvalidation) {
713 ASSERT_NO_FATAL_FAILURE(Init());
714
sfricke-samsung1c61f192021-12-31 01:53:03 -0600715 VkEventCreateInfo eci = LvlInitStruct<VkEventCreateInfo>();
716 eci.flags = 0;
unknown088160a2019-05-23 17:43:13 -0600717 VkEvent event;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600718 vk::CreateEvent(m_device->device(), &eci, nullptr, &event);
unknown088160a2019-05-23 17:43:13 -0600719
720 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
721 secondary.begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600722 vk::CmdSetEvent(secondary.handle(), event, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
unknown088160a2019-05-23 17:43:13 -0600723 secondary.end();
724
725 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600726 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600727 m_commandBuffer->end();
728
729 // destroying the event should invalidate both primary and secondary CB
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600730 vk::DestroyEvent(m_device->device(), event, nullptr);
unknown088160a2019-05-23 17:43:13 -0600731
Mark Lobodzinski20310782020-02-28 14:25:17 -0700732 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBuffer-VkEvent");
unknown088160a2019-05-23 17:43:13 -0600733 m_commandBuffer->QueueCommandBuffer(false);
734 m_errorMonitor->VerifyFound();
735}
736
737TEST_F(VkLayerTest, CommandBufferResetErrors) {
738 // Cause error due to Begin while recording CB
739 // Then cause 2 errors for attempting to reset CB w/o having
740 // VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT set for the pool from
741 // which CBs were allocated. Note that this bit is off by default.
Mark Lobodzinski20310782020-02-28 14:25:17 -0700742 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00049");
unknown088160a2019-05-23 17:43:13 -0600743
744 ASSERT_NO_FATAL_FAILURE(Init());
745
746 // Calls AllocateCommandBuffers
747 VkCommandBufferObj commandBuffer(m_device, m_commandPool);
748
749 // Force the failure by setting the Renderpass and Framebuffer fields with (fake) data
sfricke-samsung1c61f192021-12-31 01:53:03 -0600750 VkCommandBufferInheritanceInfo cmd_buf_hinfo = LvlInitStruct<VkCommandBufferInheritanceInfo>();
751 VkCommandBufferBeginInfo cmd_buf_info = LvlInitStruct<VkCommandBufferBeginInfo>();
unknown088160a2019-05-23 17:43:13 -0600752 cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
753 cmd_buf_info.pInheritanceInfo = &cmd_buf_hinfo;
754
755 // Begin CB to transition to recording state
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600756 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600757 // Can't re-begin. This should trigger error
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600758 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600759 m_errorMonitor->VerifyFound();
760
Mark Lobodzinski20310782020-02-28 14:25:17 -0700761 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkResetCommandBuffer-commandBuffer-00046");
unknown088160a2019-05-23 17:43:13 -0600762 VkCommandBufferResetFlags flags = 0; // Don't care about flags for this test
763 // Reset attempt will trigger error due to incorrect CommandPool state
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600764 vk::ResetCommandBuffer(commandBuffer.handle(), flags);
unknown088160a2019-05-23 17:43:13 -0600765 m_errorMonitor->VerifyFound();
766
Mark Lobodzinski20310782020-02-28 14:25:17 -0700767 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00050");
unknown088160a2019-05-23 17:43:13 -0600768 // Transition CB to RECORDED state
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600769 vk::EndCommandBuffer(commandBuffer.handle());
unknown088160a2019-05-23 17:43:13 -0600770 // Now attempting to Begin will implicitly reset, which triggers error
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600771 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600772 m_errorMonitor->VerifyFound();
773}
774
sfricke-samsungae9f00a2020-05-28 20:48:49 -0700775TEST_F(VkLayerTest, CommandBufferPrimaryFlags) {
776 ASSERT_NO_FATAL_FAILURE(Init());
777
778 // Calls AllocateCommandBuffers
779 VkCommandBufferObj commandBuffer(m_device, m_commandPool);
780
sfricke-samsung1c61f192021-12-31 01:53:03 -0600781 VkCommandBufferBeginInfo cmd_buf_info = LvlInitStruct<VkCommandBufferBeginInfo>();
sfricke-samsungae9f00a2020-05-28 20:48:49 -0700782 cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
783
784 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-02840");
785 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
786 m_errorMonitor->VerifyFound();
787}
788
unknown088160a2019-05-23 17:43:13 -0600789TEST_F(VkLayerTest, ClearColorAttachmentsOutsideRenderPass) {
790 // Call CmdClearAttachmentss outside of an active RenderPass
791
sfricke-samsung85584a72021-09-30 21:43:38 -0700792 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdClearAttachments: This call must be issued inside an active render pass");
unknown088160a2019-05-23 17:43:13 -0600793
794 ASSERT_NO_FATAL_FAILURE(Init());
795 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
796
797 // Start no RenderPass
798 m_commandBuffer->begin();
799
800 VkClearAttachment color_attachment;
801 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
802 color_attachment.clearValue.color.float32[0] = 0;
803 color_attachment.clearValue.color.float32[1] = 0;
804 color_attachment.clearValue.color.float32[2] = 0;
805 color_attachment.clearValue.color.float32[3] = 0;
806 color_attachment.colorAttachment = 0;
Mark Lobodzinskid5447512019-06-28 09:56:36 -0600807 VkClearRect clear_rect = {{{0, 0}, {32, 32}}, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600808 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
unknown088160a2019-05-23 17:43:13 -0600809
810 m_errorMonitor->VerifyFound();
811}
812
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600813TEST_F(VkLayerTest, ClearColorAttachmentsZeroLayercount) {
814 TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a layerCount of zero.");
815
Mark Lobodzinski20310782020-02-28 14:25:17 -0700816 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-layerCount-01934");
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600817
818 ASSERT_NO_FATAL_FAILURE(Init());
819 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
820
821 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600822 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600823
824 VkClearAttachment color_attachment;
825 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
826 color_attachment.clearValue.color.float32[0] = 0;
827 color_attachment.clearValue.color.float32[1] = 0;
828 color_attachment.clearValue.color.float32[2] = 0;
829 color_attachment.clearValue.color.float32[3] = 0;
830 color_attachment.colorAttachment = 0;
831 VkClearRect clear_rect = {{{0, 0}, {32, 32}}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600832 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600833
834 m_errorMonitor->VerifyFound();
835}
836
sfricke-samsungf0f3d8b2020-04-25 02:20:47 -0700837TEST_F(VkLayerTest, ClearColorAttachmentsZeroExtent) {
838 TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a rect2D extent of zero.");
839
840 ASSERT_NO_FATAL_FAILURE(Init());
841 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
842
843 m_commandBuffer->begin();
844 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
845
846 VkClearAttachment color_attachment;
847 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
848 color_attachment.clearValue.color.float32[0] = 0;
849 color_attachment.clearValue.color.float32[1] = 0;
850 color_attachment.clearValue.color.float32[2] = 0;
851 color_attachment.clearValue.color.float32[3] = 0;
852 color_attachment.colorAttachment = 0;
853 VkClearRect clear_rect = {};
854 clear_rect.rect.offset = {0, 0};
855 clear_rect.baseArrayLayer = 0;
856 clear_rect.layerCount = 1;
857
858 clear_rect.rect.extent = {0, 1};
859 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-rect-02682");
860 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
861 m_errorMonitor->VerifyFound();
862
863 clear_rect.rect.extent = {1, 0};
864 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-rect-02683");
865 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
866 m_errorMonitor->VerifyFound();
867}
868
sfricke-samsung6141db32020-10-26 03:31:38 -0700869TEST_F(VkLayerTest, ClearAttachmentsInvalidAspectMasks) {
870 TEST_DESCRIPTION("Check VkClearAttachment invalid aspect masks.");
871
872 ASSERT_NO_FATAL_FAILURE(Init());
873 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
874
875 m_commandBuffer->begin();
876 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
877
878 VkClearAttachment attachment;
879 attachment.clearValue.color.float32[0] = 0;
880 attachment.clearValue.color.float32[1] = 0;
881 attachment.clearValue.color.float32[2] = 0;
882 attachment.clearValue.color.float32[3] = 0;
883 attachment.colorAttachment = 0;
884 VkClearRect clear_rect = {};
885 clear_rect.rect.offset = {0, 0};
886 clear_rect.rect.extent = {1, 1};
887 clear_rect.baseArrayLayer = 0;
888 clear_rect.layerCount = 1;
889
890 attachment.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
891 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-00020");
892 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
893 m_errorMonitor->VerifyFound();
894
895 attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
896 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-00020");
897 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
898 m_errorMonitor->VerifyFound();
899
900 attachment.aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT;
901 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-02246");
902 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
903 m_errorMonitor->VerifyFound();
904
905 attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
906 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-02246");
907 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
908 m_errorMonitor->VerifyFound();
909}
910
sfricke-samsung91f4a542020-10-21 00:29:17 -0700911TEST_F(VkLayerTest, ClearAttachmentsImplicitCheck) {
912 TEST_DESCRIPTION("Check VkClearAttachment implicit VUs.");
913
914 ASSERT_NO_FATAL_FAILURE(Init());
915 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
916
917 m_commandBuffer->begin();
918 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
919
920 VkClearAttachment color_attachment;
921 color_attachment.clearValue.color.float32[0] = 0;
922 color_attachment.clearValue.color.float32[1] = 0;
923 color_attachment.clearValue.color.float32[2] = 0;
924 color_attachment.clearValue.color.float32[3] = 0;
925 color_attachment.colorAttachment = 0;
926 VkClearRect clear_rect = {};
927 clear_rect.rect.offset = {0, 0};
928 clear_rect.rect.extent = {1, 1};
929 clear_rect.baseArrayLayer = 0;
930 clear_rect.layerCount = 1;
931
932 color_attachment.aspectMask = 0;
933 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-requiredbitmask");
934 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
935 m_errorMonitor->VerifyFound();
936
937 color_attachment.aspectMask = 0xffffffff;
938 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkClearAttachment-aspectMask-parameter");
939 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
940 m_errorMonitor->VerifyFound();
941}
942
sfricke-samsung87b09512020-10-26 03:35:42 -0700943TEST_F(VkLayerTest, ClearColorAttachmentsDepthStencil) {
944 TEST_DESCRIPTION("Call CmdClearAttachments with invalid depth/stencil aspect masks.");
945
946 ASSERT_NO_FATAL_FAILURE(Init());
947 // Creates a color attachment
948 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
949
950 m_commandBuffer->begin();
951 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
952
953 VkClearAttachment attachment;
954 attachment.clearValue.color.float32[0] = 0;
955 attachment.clearValue.color.float32[1] = 0;
956 attachment.clearValue.color.float32[2] = 0;
957 attachment.clearValue.color.float32[3] = 0;
958 attachment.colorAttachment = 0;
959 VkClearRect clear_rect = {};
960 clear_rect.rect.offset = {0, 0};
961 clear_rect.rect.extent = {1, 1};
962 clear_rect.baseArrayLayer = 0;
963 clear_rect.layerCount = 1;
964
sfricke-samsung87b09512020-10-26 03:35:42 -0700965 attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
966 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
sfricke-samsung87b09512020-10-26 03:35:42 -0700967
968 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-aspectMask-02502");
969 attachment.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
970 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
971 m_errorMonitor->VerifyFound();
972
973 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-aspectMask-02503");
974 attachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
975 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &attachment, 1, &clear_rect);
976 m_errorMonitor->VerifyFound();
977}
978
unknown088160a2019-05-23 17:43:13 -0600979TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB) {
980 TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a primary command buffer (should only be secondary)");
981
982 ASSERT_NO_FATAL_FAILURE(Init());
983 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
984
985 // An empty primary command buffer
986 VkCommandBufferObj cb(m_device, m_commandPool);
987 cb.begin();
988 cb.end();
989
990 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600991 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -0600992 VkCommandBuffer handle = cb.handle();
993
Mark Lobodzinski20310782020-02-28 14:25:17 -0700994 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00088");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600995 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &handle);
unknown088160a2019-05-23 17:43:13 -0600996 m_errorMonitor->VerifyFound();
997
998 m_errorMonitor->SetUnexpectedError("All elements of pCommandBuffers must not be in the pending state");
999
1000 m_commandBuffer->EndRenderPass();
1001 m_commandBuffer->end();
1002}
1003
Petr Kraus8e53cf02020-01-03 05:30:04 +01001004TEST_F(VkLayerTest, ExecuteCommandsToSecondaryCB) {
1005 TEST_DESCRIPTION("Attempt vkCmdExecuteCommands to a Secondary command buffer");
1006
1007 ASSERT_NO_FATAL_FAILURE(Init());
1008
1009 VkCommandBufferObj main_cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1010 VkCommandBufferObj secondary_cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1011 secondary_cb.begin();
1012 secondary_cb.end();
1013
1014 main_cb.begin();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001015 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-bufferlevel");
Petr Kraus8e53cf02020-01-03 05:30:04 +01001016 vk::CmdExecuteCommands(main_cb.handle(), 1, &secondary_cb.handle());
1017 m_errorMonitor->VerifyFound();
1018}
1019
unknown088160a2019-05-23 17:43:13 -06001020TEST_F(VkLayerTest, InvalidVertexAttributeAlignment) {
1021 TEST_DESCRIPTION("Check for proper aligment of attribAddress which depends on a bound pipeline and on a bound vertex buffer");
1022
1023 ASSERT_NO_FATAL_FAILURE(Init());
1024 ASSERT_NO_FATAL_FAILURE(InitViewport());
1025 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1026
1027 const VkPipelineLayoutObj pipeline_layout(m_device);
1028
1029 struct VboEntry {
1030 uint16_t input0[2];
1031 uint32_t input1;
1032 float input2[4];
1033 };
1034
1035 const unsigned vbo_entry_count = 3;
1036 const VboEntry vbo_data[vbo_entry_count] = {};
1037
1038 VkConstantBufferObj vbo(m_device, static_cast<int>(sizeof(VboEntry) * vbo_entry_count),
1039 reinterpret_cast<const void *>(vbo_data), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
1040
1041 VkVertexInputBindingDescription input_binding;
1042 input_binding.binding = 0;
1043 input_binding.stride = sizeof(VboEntry);
1044 input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
1045
1046 VkVertexInputAttributeDescription input_attribs[3];
1047
1048 input_attribs[0].binding = 0;
1049 // Location switch between attrib[0] and attrib[1] is intentional
1050 input_attribs[0].location = 1;
1051 input_attribs[0].format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
1052 input_attribs[0].offset = offsetof(VboEntry, input1);
1053
1054 input_attribs[1].binding = 0;
1055 input_attribs[1].location = 0;
1056 input_attribs[1].format = VK_FORMAT_R16G16_UNORM;
1057 input_attribs[1].offset = offsetof(VboEntry, input0);
1058
1059 input_attribs[2].binding = 0;
1060 input_attribs[2].location = 2;
1061 input_attribs[2].format = VK_FORMAT_R32G32B32A32_SFLOAT;
1062 input_attribs[2].offset = offsetof(VboEntry, input2);
1063
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07001064 char const *vsSource = R"glsl(
1065 #version 450
1066 layout(location = 0) in vec2 input0;
1067 layout(location = 1) in vec4 input1;
1068 layout(location = 2) in vec4 input2;
1069 void main(){
1070 gl_Position = input1 + input2;
1071 gl_Position.xy += input0;
1072 }
1073 )glsl";
unknown088160a2019-05-23 17:43:13 -06001074
sfricke-samsungae54c1e2022-01-21 05:35:21 -08001075 VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
1076 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06001077
1078 VkPipelineObj pipe1(m_device);
1079 pipe1.AddDefaultColorAttachment();
1080 pipe1.AddShader(&vs);
1081 pipe1.AddShader(&fs);
1082 pipe1.AddVertexInputBindings(&input_binding, 1);
1083 pipe1.AddVertexInputAttribs(&input_attribs[0], 3);
1084 pipe1.SetViewport(m_viewports);
1085 pipe1.SetScissor(m_scissors);
1086 pipe1.CreateVKPipeline(pipeline_layout.handle(), renderPass());
1087
1088 input_binding.stride = 6;
1089
1090 VkPipelineObj pipe2(m_device);
1091 pipe2.AddDefaultColorAttachment();
1092 pipe2.AddShader(&vs);
1093 pipe2.AddShader(&fs);
1094 pipe2.AddVertexInputBindings(&input_binding, 1);
1095 pipe2.AddVertexInputAttribs(&input_attribs[0], 3);
1096 pipe2.SetViewport(m_viewports);
1097 pipe2.SetScissor(m_scissors);
1098 pipe2.CreateVKPipeline(pipeline_layout.handle(), renderPass());
1099
1100 m_commandBuffer->begin();
1101 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
1102
1103 // Test with invalid buffer offset
1104 VkDeviceSize offset = 1;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001105 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe1.handle());
1106 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
sfricke-samsung0cb6c4e2022-02-08 14:49:23 -08001107 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721"); // attribute 0
1108 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721"); // attribute 1
1109 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721"); // attribute 2
unknown088160a2019-05-23 17:43:13 -06001110 m_commandBuffer->Draw(1, 0, 0, 0);
1111 m_errorMonitor->VerifyFound();
1112
1113 // Test with invalid buffer stride
1114 offset = 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001115 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2.handle());
1116 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
sfricke-samsung0cb6c4e2022-02-08 14:49:23 -08001117 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721"); // attribute 0
unknown088160a2019-05-23 17:43:13 -06001118 // Attribute[1] is aligned properly even with a wrong stride
sfricke-samsung0cb6c4e2022-02-08 14:49:23 -08001119 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721"); // attribute 2
unknown088160a2019-05-23 17:43:13 -06001120 m_commandBuffer->Draw(1, 0, 0, 0);
1121 m_errorMonitor->VerifyFound();
1122
1123 m_commandBuffer->EndRenderPass();
1124 m_commandBuffer->end();
1125}
1126
1127TEST_F(VkLayerTest, NonSimultaneousSecondaryMarksPrimary) {
1128 ASSERT_NO_FATAL_FAILURE(Init());
locke-lunarg77b9f7c2019-06-18 00:06:03 -06001129 const char *simultaneous_use_message = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBufferSimultaneousUse";
unknown088160a2019-05-23 17:43:13 -06001130
1131 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1132
1133 secondary.begin();
1134 secondary.end();
1135
1136 VkCommandBufferBeginInfo cbbi = {
1137 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1138 nullptr,
1139 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
1140 nullptr,
1141 };
1142
1143 m_commandBuffer->begin(&cbbi);
Mark Lobodzinski20310782020-02-28 14:25:17 -07001144 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001145 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06001146 m_errorMonitor->VerifyFound();
1147 m_commandBuffer->end();
1148}
1149
1150TEST_F(VkLayerTest, SimultaneousUseSecondaryTwoExecutes) {
1151 ASSERT_NO_FATAL_FAILURE(Init());
1152
John Zulauff1640d12019-08-13 15:39:58 -06001153 const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00092";
unknown088160a2019-05-23 17:43:13 -06001154
1155 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1156
sfricke-samsung1c61f192021-12-31 01:53:03 -06001157 VkCommandBufferInheritanceInfo inh = LvlInitStruct<VkCommandBufferInheritanceInfo>();
unknown088160a2019-05-23 17:43:13 -06001158 VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh};
1159
1160 secondary.begin(&cbbi);
1161 secondary.end();
1162
1163 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001164 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
Mark Lobodzinski20310782020-02-28 14:25:17 -07001165 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001166 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06001167 m_errorMonitor->VerifyFound();
1168 m_commandBuffer->end();
1169}
1170
1171TEST_F(VkLayerTest, SimultaneousUseSecondarySingleExecute) {
1172 ASSERT_NO_FATAL_FAILURE(Init());
1173
1174 // variation on previous test executing the same CB twice in the same
1175 // CmdExecuteCommands call
1176
John Zulauff1640d12019-08-13 15:39:58 -06001177 const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00093";
unknown088160a2019-05-23 17:43:13 -06001178
1179 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1180
sfricke-samsung1c61f192021-12-31 01:53:03 -06001181 VkCommandBufferInheritanceInfo inh = LvlInitStruct<VkCommandBufferInheritanceInfo>();
unknown088160a2019-05-23 17:43:13 -06001182 VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh};
1183
1184 secondary.begin(&cbbi);
1185 secondary.end();
1186
1187 m_commandBuffer->begin();
1188 VkCommandBuffer cbs[] = {secondary.handle(), secondary.handle()};
Mark Lobodzinski20310782020-02-28 14:25:17 -07001189 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001190 vk::CmdExecuteCommands(m_commandBuffer->handle(), 2, cbs);
unknown088160a2019-05-23 17:43:13 -06001191 m_errorMonitor->VerifyFound();
1192 m_commandBuffer->end();
1193}
1194
1195TEST_F(VkLayerTest, SimultaneousUseOneShot) {
1196 TEST_DESCRIPTION("Submit the same command buffer twice in one submit looking for simultaneous use and one time submit errors");
1197 const char *simultaneous_use_message = "is already in use and is not marked for simultaneous use";
1198 const char *one_shot_message = "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted";
1199 ASSERT_NO_FATAL_FAILURE(Init());
1200
1201 VkCommandBuffer cmd_bufs[2];
sfricke-samsung1c61f192021-12-31 01:53:03 -06001202 VkCommandBufferAllocateInfo alloc_info = LvlInitStruct<VkCommandBufferAllocateInfo>();
unknown088160a2019-05-23 17:43:13 -06001203 alloc_info.commandBufferCount = 2;
1204 alloc_info.commandPool = m_commandPool->handle();
1205 alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001206 vk::AllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs);
unknown088160a2019-05-23 17:43:13 -06001207
sfricke-samsung1c61f192021-12-31 01:53:03 -06001208 VkCommandBufferBeginInfo cb_binfo = LvlInitStruct<VkCommandBufferBeginInfo>();
unknown088160a2019-05-23 17:43:13 -06001209 cb_binfo.pInheritanceInfo = VK_NULL_HANDLE;
1210 cb_binfo.flags = 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001211 vk::BeginCommandBuffer(cmd_bufs[0], &cb_binfo);
unknown088160a2019-05-23 17:43:13 -06001212 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001213 vk::CmdSetViewport(cmd_bufs[0], 0, 1, &viewport);
1214 vk::EndCommandBuffer(cmd_bufs[0]);
unknown088160a2019-05-23 17:43:13 -06001215 VkCommandBuffer duplicates[2] = {cmd_bufs[0], cmd_bufs[0]};
1216
sfricke-samsung1c61f192021-12-31 01:53:03 -06001217 VkSubmitInfo submit_info = LvlInitStruct<VkSubmitInfo>();
unknown088160a2019-05-23 17:43:13 -06001218 submit_info.commandBufferCount = 2;
1219 submit_info.pCommandBuffers = duplicates;
Mark Lobodzinski20310782020-02-28 14:25:17 -07001220 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001221 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06001222 m_errorMonitor->VerifyFound();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001223 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06001224
1225 // Set one time use and now look for one time submit
1226 duplicates[0] = duplicates[1] = cmd_bufs[1];
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06001227 cb_binfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001228 vk::BeginCommandBuffer(cmd_bufs[1], &cb_binfo);
1229 vk::CmdSetViewport(cmd_bufs[1], 0, 1, &viewport);
1230 vk::EndCommandBuffer(cmd_bufs[1]);
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06001231 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkQueueSubmit-pCommandBuffers-00071");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001232 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, one_shot_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001233 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06001234 m_errorMonitor->VerifyFound();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001235 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06001236}
1237
1238TEST_F(VkLayerTest, DrawTimeImageViewTypeMismatchWithPipeline) {
1239 TEST_DESCRIPTION(
1240 "Test that an error is produced when an image view type does not match the dimensionality declared in the shader");
1241
Mark Lobodzinski20310782020-02-28 14:25:17 -07001242 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires an image view of type VK_IMAGE_VIEW_TYPE_3D");
unknown088160a2019-05-23 17:43:13 -06001243
1244 ASSERT_NO_FATAL_FAILURE(Init());
1245 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1246
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07001247 char const *fsSource = R"glsl(
1248 #version 450
1249 layout(set=0, binding=0) uniform sampler3D s;
1250 layout(location=0) out vec4 color;
1251 void main() {
1252 color = texture(s, vec3(0));
1253 }
1254 )glsl";
sfricke-samsungae54c1e2022-01-21 05:35:21 -08001255 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
1256 VkShaderObj fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06001257
1258 VkPipelineObj pipe(m_device);
1259 pipe.AddShader(&vs);
1260 pipe.AddShader(&fs);
1261 pipe.AddDefaultColorAttachment();
1262
1263 VkTextureObj texture(m_device, nullptr);
1264 VkSamplerObj sampler(m_device);
1265
1266 VkDescriptorSetObj descriptorSet(m_device);
1267 descriptorSet.AppendSamplerTexture(&sampler, &texture);
1268 descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
1269
1270 VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
1271 ASSERT_VK_SUCCESS(err);
1272
1273 m_commandBuffer->begin();
1274 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
1275
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001276 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001277 m_commandBuffer->BindDescriptorSet(descriptorSet);
1278
1279 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001280 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001281 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001282 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001283
1284 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001285 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001286
1287 m_errorMonitor->VerifyFound();
1288
1289 m_commandBuffer->EndRenderPass();
1290 m_commandBuffer->end();
1291}
1292
1293TEST_F(VkLayerTest, DrawTimeImageMultisampleMismatchWithPipeline) {
1294 TEST_DESCRIPTION(
1295 "Test that an error is produced when a multisampled images are consumed via singlesample images types in the shader, or "
1296 "vice versa.");
1297
Mark Lobodzinski20310782020-02-28 14:25:17 -07001298 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires bound image to have multiple samples");
unknown088160a2019-05-23 17:43:13 -06001299
1300 ASSERT_NO_FATAL_FAILURE(Init());
1301 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1302
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07001303 char const *fsSource = R"glsl(
1304 #version 450
1305 layout(set=0, binding=0) uniform sampler2DMS s;
1306 layout(location=0) out vec4 color;
1307 void main() {
1308 color = texelFetch(s, ivec2(0), 0);
1309 }
1310 )glsl";
sfricke-samsungae54c1e2022-01-21 05:35:21 -08001311 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
1312 VkShaderObj fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06001313
1314 VkPipelineObj pipe(m_device);
1315 pipe.AddShader(&vs);
1316 pipe.AddShader(&fs);
1317 pipe.AddDefaultColorAttachment();
1318
1319 VkTextureObj texture(m_device, nullptr); // THIS LINE CAUSES CRASH ON MALI
1320 VkSamplerObj sampler(m_device);
1321
1322 VkDescriptorSetObj descriptorSet(m_device);
1323 descriptorSet.AppendSamplerTexture(&sampler, &texture);
1324 descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
1325
1326 VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
1327 ASSERT_VK_SUCCESS(err);
1328
1329 m_commandBuffer->begin();
1330 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
1331
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001332 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001333 m_commandBuffer->BindDescriptorSet(descriptorSet);
1334
1335 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001336 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001337 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001338 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001339
1340 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001341 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001342
1343 m_errorMonitor->VerifyFound();
1344
1345 m_commandBuffer->EndRenderPass();
1346 m_commandBuffer->end();
1347}
1348
1349TEST_F(VkLayerTest, DrawTimeImageComponentTypeMismatchWithPipeline) {
1350 TEST_DESCRIPTION(
1351 "Test that an error is produced when the component type of an imageview disagrees with the type in the shader.");
1352
Mark Lobodzinski20310782020-02-28 14:25:17 -07001353 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "SINT component type, but bound descriptor");
unknown088160a2019-05-23 17:43:13 -06001354
1355 ASSERT_NO_FATAL_FAILURE(Init());
1356 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1357
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07001358 char const *fsSource = R"glsl(
1359 #version 450
1360 layout(set=0, binding=0) uniform isampler2D s;
1361 layout(location=0) out vec4 color;
1362 void main() {
1363 color = texelFetch(s, ivec2(0), 0);
1364 }
1365 )glsl";
sfricke-samsungae54c1e2022-01-21 05:35:21 -08001366 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
1367 VkShaderObj fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06001368
1369 VkPipelineObj pipe(m_device);
1370 pipe.AddShader(&vs);
1371 pipe.AddShader(&fs);
1372 pipe.AddDefaultColorAttachment();
1373
1374 VkTextureObj texture(m_device, nullptr); // UNORM texture by default, incompatible with isampler2D
1375 VkSamplerObj sampler(m_device);
1376
1377 VkDescriptorSetObj descriptorSet(m_device);
1378 descriptorSet.AppendSamplerTexture(&sampler, &texture);
1379 descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
1380
1381 VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
1382 ASSERT_VK_SUCCESS(err);
1383
1384 m_commandBuffer->begin();
1385 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
1386
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001387 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001388 m_commandBuffer->BindDescriptorSet(descriptorSet);
1389
1390 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001391 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001392 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001393 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001394
1395 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001396 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001397
1398 m_errorMonitor->VerifyFound();
1399
1400 m_commandBuffer->EndRenderPass();
1401 m_commandBuffer->end();
1402}
1403
unknown088160a2019-05-23 17:43:13 -06001404TEST_F(VkLayerTest, CopyImageLayerCountMismatch) {
1405 TEST_DESCRIPTION(
1406 "Try to copy between images with the source subresource having a different layerCount than the destination subresource");
sfricke-samsung30b094c2020-05-30 11:42:11 -07001407 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
1408 bool maintenance1 = false;
Mike Schuchardt7cc57842021-09-15 10:49:59 -07001409 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME)) {
1410 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung30b094c2020-05-30 11:42:11 -07001411 maintenance1 = true;
1412 }
1413 ASSERT_NO_FATAL_FAILURE(InitState());
1414
1415 VkFormat image_format = VK_FORMAT_B8G8R8A8_UNORM;
1416 VkFormatProperties format_props;
1417 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props);
1418 if ((format_props.optimalTilingFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) == 0) {
1419 printf("%s Transfer for format is not supported.\n", kSkipPrefix);
1420 return;
1421 }
unknown088160a2019-05-23 17:43:13 -06001422
1423 // Create two images to copy between
1424 VkImageObj src_image_obj(m_device);
1425 VkImageObj dst_image_obj(m_device);
1426
sfricke-samsung1c61f192021-12-31 01:53:03 -06001427 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06001428 image_create_info.imageType = VK_IMAGE_TYPE_2D;
sfricke-samsung30b094c2020-05-30 11:42:11 -07001429 image_create_info.format = image_format;
unknown088160a2019-05-23 17:43:13 -06001430 image_create_info.extent.width = 32;
1431 image_create_info.extent.height = 32;
1432 image_create_info.extent.depth = 1;
1433 image_create_info.mipLevels = 1;
1434 image_create_info.arrayLayers = 4;
1435 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
1436 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
1437 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1438 image_create_info.flags = 0;
1439
1440 src_image_obj.init(&image_create_info);
1441 ASSERT_TRUE(src_image_obj.initialized());
1442
1443 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1444 dst_image_obj.init(&image_create_info);
1445 ASSERT_TRUE(dst_image_obj.initialized());
1446
1447 m_commandBuffer->begin();
1448 VkImageCopy copyRegion;
1449 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1450 copyRegion.srcSubresource.mipLevel = 0;
1451 copyRegion.srcSubresource.baseArrayLayer = 0;
1452 copyRegion.srcSubresource.layerCount = 1;
1453 copyRegion.srcOffset.x = 0;
1454 copyRegion.srcOffset.y = 0;
1455 copyRegion.srcOffset.z = 0;
1456 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1457 copyRegion.dstSubresource.mipLevel = 0;
1458 copyRegion.dstSubresource.baseArrayLayer = 0;
1459 // Introduce failure by forcing the dst layerCount to differ from src
1460 copyRegion.dstSubresource.layerCount = 3;
1461 copyRegion.dstOffset.x = 0;
1462 copyRegion.dstOffset.y = 0;
1463 copyRegion.dstOffset.z = 0;
1464 copyRegion.extent.width = 1;
1465 copyRegion.extent.height = 1;
1466 copyRegion.extent.depth = 1;
1467
sfricke-samsung30b094c2020-05-30 11:42:11 -07001468 const char *vuid = (maintenance1 == true) ? "VUID-VkImageCopy-extent-00140" : "VUID-VkImageCopy-layerCount-00138";
1469 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
unknown088160a2019-05-23 17:43:13 -06001470 m_commandBuffer->CopyImage(src_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
1471 &copyRegion);
1472 m_errorMonitor->VerifyFound();
1473}
1474
1475TEST_F(VkLayerTest, CompressedImageMipCopyTests) {
1476 TEST_DESCRIPTION("Image/Buffer copies for higher mip levels");
1477
Jeff Leger465acf52020-10-12 18:07:16 -04001478 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
1479
1480 bool copy_commands2 = false;
1481 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME)) {
1482 m_device_extension_names.push_back(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME);
1483 copy_commands2 = true;
1484 }
1485 ASSERT_NO_FATAL_FAILURE(InitState());
1486
1487 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2Function = nullptr;
Jeff Leger465acf52020-10-12 18:07:16 -04001488 if (copy_commands2) {
1489 vkCmdCopyBufferToImage2Function =
1490 (PFN_vkCmdCopyBufferToImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdCopyBufferToImage2KHR");
Jeff Leger465acf52020-10-12 18:07:16 -04001491 }
unknown088160a2019-05-23 17:43:13 -06001492
1493 VkPhysicalDeviceFeatures device_features = {};
1494 ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
1495 VkFormat compressed_format = VK_FORMAT_UNDEFINED;
1496 if (device_features.textureCompressionBC) {
1497 compressed_format = VK_FORMAT_BC3_SRGB_BLOCK;
1498 } else if (device_features.textureCompressionETC2) {
1499 compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
1500 } else if (device_features.textureCompressionASTC_LDR) {
1501 compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
1502 } else {
1503 printf("%s No compressed formats supported - CompressedImageMipCopyTests skipped.\n", kSkipPrefix);
1504 return;
1505 }
1506
sfricke-samsung1c61f192021-12-31 01:53:03 -06001507 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06001508 ci.flags = 0;
1509 ci.imageType = VK_IMAGE_TYPE_2D;
1510 ci.format = compressed_format;
1511 ci.extent = {32, 32, 1};
1512 ci.mipLevels = 6;
1513 ci.arrayLayers = 1;
1514 ci.samples = VK_SAMPLE_COUNT_1_BIT;
1515 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
1516 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1517 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1518 ci.queueFamilyIndexCount = 0;
1519 ci.pQueueFamilyIndices = NULL;
1520 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1521
1522 VkImageObj image(m_device);
1523 image.init(&ci);
1524 ASSERT_TRUE(image.initialized());
1525
1526 VkImageObj odd_image(m_device);
1527 ci.extent = {31, 32, 1}; // Mips are [31,32] [15,16] [7,8] [3,4], [1,2] [1,1]
1528 odd_image.init(&ci);
1529 ASSERT_TRUE(odd_image.initialized());
1530
1531 // Allocate buffers
1532 VkMemoryPropertyFlags reqs = 0;
1533 VkBufferObj buffer_1024, buffer_64, buffer_16, buffer_8;
1534 buffer_1024.init_as_src_and_dst(*m_device, 1024, reqs);
1535 buffer_64.init_as_src_and_dst(*m_device, 64, reqs);
1536 buffer_16.init_as_src_and_dst(*m_device, 16, reqs);
1537 buffer_8.init_as_src_and_dst(*m_device, 8, reqs);
1538
1539 VkBufferImageCopy region = {};
1540 region.bufferRowLength = 0;
1541 region.bufferImageHeight = 0;
1542 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1543 region.imageSubresource.layerCount = 1;
1544 region.imageOffset = {0, 0, 0};
1545 region.bufferOffset = 0;
1546
1547 // start recording
1548 m_commandBuffer->begin();
1549
locke-lunargdf00db02020-03-04 19:00:57 -07001550 VkMemoryBarrier mem_barriers[3];
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001551 mem_barriers[0] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001552 mem_barriers[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1553 mem_barriers[0].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001554 mem_barriers[1] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001555 mem_barriers[1].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1556 mem_barriers[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001557 mem_barriers[2] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001558 mem_barriers[2].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1559 mem_barriers[2].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1560
unknown088160a2019-05-23 17:43:13 -06001561 // Mip level copies that work - 5 levels
unknown088160a2019-05-23 17:43:13 -06001562
1563 // Mip 0 should fit in 1k buffer - 1k texels @ 1b each
1564 region.imageExtent = {32, 32, 1};
1565 region.imageSubresource.mipLevel = 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001566 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_1024.handle(), 1, &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001567
1568 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1569 &mem_barriers[2], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001570 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_1024.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001571
1572 // Mip 2 should fit in 64b buffer - 64 texels @ 1b each
1573 region.imageExtent = {8, 8, 1};
1574 region.imageSubresource.mipLevel = 2;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001575 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64.handle(), 1, &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001576
1577 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1578 &mem_barriers[1], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001579 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001580
1581 // Mip 3 should fit in 16b buffer - 16 texels @ 1b each
1582 region.imageExtent = {4, 4, 1};
1583 region.imageSubresource.mipLevel = 3;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001584 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001585
1586 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1587 &mem_barriers[1], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001588 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001589
1590 // Mip 4&5 should fit in 16b buffer with no complaint - 4 & 1 texels @ 1b each
1591 region.imageExtent = {2, 2, 1};
1592 region.imageSubresource.mipLevel = 4;
locke-lunargdf00db02020-03-04 19:00:57 -07001593
1594 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1595 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001596 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001597
1598 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1599 &mem_barriers[1], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001600 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001601
1602 region.imageExtent = {1, 1, 1};
1603 region.imageSubresource.mipLevel = 5;
locke-lunargdf00db02020-03-04 19:00:57 -07001604
1605 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1606 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001607 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001608
1609 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1610 &mem_barriers[1], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001611 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001612
1613 // Buffer must accommodate a full compressed block, regardless of texel count
Mark Lobodzinski20310782020-02-28 14:25:17 -07001614 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001615 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_8.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001616 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001617 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-00171");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001618 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_8.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001619 m_errorMonitor->VerifyFound();
1620
1621 // Copy width < compressed block size, but not the full mip width
1622 region.imageExtent = {1, 2, 1};
1623 region.imageSubresource.mipLevel = 4;
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001624 // width not a multiple of compressed block width
1625 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageExtent-00207");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001626 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001627 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001628 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001629 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04001630
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001631 m_errorMonitor->SetDesiredFailureMsg(
1632 kErrorBit, "VUID-vkCmdCopyBufferToImage-imageExtent-00207"); // width not a multiple of compressed block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001633 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001634 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001635 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001636 m_errorMonitor->VerifyFound();
1637
1638 // Copy height < compressed block size but not the full mip height
1639 region.imageExtent = {2, 1, 1};
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001640 m_errorMonitor->SetDesiredFailureMsg(
1641 kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageExtent-00208"); // height not a multiple of compressed block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001642 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001643 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001644 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001645 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04001646
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001647 m_errorMonitor->SetDesiredFailureMsg(
1648 kErrorBit, "VUID-vkCmdCopyBufferToImage-imageExtent-00208"); // height not a multiple of compressed block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001649 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001650 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001651 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001652 m_errorMonitor->VerifyFound();
1653
1654 // Offsets must be multiple of compressed block size
1655 region.imageOffset = {1, 1, 0};
1656 region.imageExtent = {1, 1, 1};
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001657 // imageOffset not a multiple of block size
1658 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageOffset-00205");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001659 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001660 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001661 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001662 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04001663
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001664 m_errorMonitor->SetDesiredFailureMsg(
1665 kErrorBit, "VUID-vkCmdCopyBufferToImage-imageOffset-00205"); // imageOffset not a multiple of block size
Mark Lobodzinski20310782020-02-28 14:25:17 -07001666 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001667 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001668 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001669 m_errorMonitor->VerifyFound();
1670
Jeff Leger465acf52020-10-12 18:07:16 -04001671 // Equivalent test using KHR_copy_commands2
1672 if (copy_commands2 && vkCmdCopyBufferToImage2Function) {
1673 const VkBufferImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR,
1674 NULL,
1675 region.bufferOffset,
1676 region.bufferRowLength,
1677 region.bufferImageHeight,
1678 region.imageSubresource,
1679 region.imageOffset,
1680 region.imageExtent};
1681 const VkCopyBufferToImageInfo2KHR copy_buffer_to_image_info2 = {VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR,
1682 NULL,
1683 buffer_16.handle(),
1684 image.handle(),
1685 VK_IMAGE_LAYOUT_GENERAL,
1686 1,
1687 &region2};
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001688 m_errorMonitor->SetDesiredFailureMsg(
Tony-LunarG953d55a2021-11-11 14:20:25 -07001689 kErrorBit, "VUID-VkCopyBufferToImageInfo2-imageOffset-00205"); // imageOffset not a multiple of block size
Jeff Leger465acf52020-10-12 18:07:16 -04001690 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Tony-LunarG953d55a2021-11-11 14:20:25 -07001691 "VUID-VkCopyBufferToImageInfo2-imageOffset-01793"); // image transfer granularity
Jeff Leger465acf52020-10-12 18:07:16 -04001692 vkCmdCopyBufferToImage2Function(m_commandBuffer->handle(), &copy_buffer_to_image_info2);
1693 m_errorMonitor->VerifyFound();
1694 }
1695
unknown088160a2019-05-23 17:43:13 -06001696 // Offset + extent width = mip width - should succeed
1697 region.imageOffset = {4, 4, 0};
1698 region.imageExtent = {3, 4, 1};
1699 region.imageSubresource.mipLevel = 2;
locke-lunargdf00db02020-03-04 19:00:57 -07001700
1701 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1702 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001703 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1,
1704 &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001705
1706 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1707 &mem_barriers[1], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001708 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1709 &region);
unknown088160a2019-05-23 17:43:13 -06001710
unknown088160a2019-05-23 17:43:13 -06001711 // Offset + extent width < mip width and not a multiple of block width - should fail
1712 region.imageExtent = {3, 3, 1};
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001713 m_errorMonitor->SetDesiredFailureMsg(
1714 kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageExtent-00208"); // offset+extent not a multiple of block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001715 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001716 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001717 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1,
1718 &region);
unknown088160a2019-05-23 17:43:13 -06001719 m_errorMonitor->VerifyFound();
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07001720 m_errorMonitor->SetDesiredFailureMsg(
1721 kErrorBit, "VUID-vkCmdCopyBufferToImage-imageExtent-00208"); // offset+extent not a multiple of block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001722 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001723 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001724 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1725 &region);
unknown088160a2019-05-23 17:43:13 -06001726 m_errorMonitor->VerifyFound();
1727}
1728
1729TEST_F(VkLayerTest, ImageBufferCopyTests) {
1730 TEST_DESCRIPTION("Image to buffer and buffer to image tests");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001731
1732 // Enable KHR multiplane req'd extensions for multi-planar copy tests
1733 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
1734 VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
1735 if (mp_extensions) {
1736 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
1737 }
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07001738 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor, nullptr));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07001739 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001740 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
1741 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
1742 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
1743 if (mp_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07001744 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001745 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
1746 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
1747 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
1748 }
1749 ASSERT_NO_FATAL_FAILURE(InitState());
unknown088160a2019-05-23 17:43:13 -06001750
1751 // Bail if any dimension of transfer granularity is 0.
1752 auto index = m_device->graphics_queue_node_index_;
1753 auto queue_family_properties = m_device->phy().queue_properties();
1754 if ((queue_family_properties[index].minImageTransferGranularity.depth == 0) ||
1755 (queue_family_properties[index].minImageTransferGranularity.width == 0) ||
1756 (queue_family_properties[index].minImageTransferGranularity.height == 0)) {
1757 printf("%s Subresource copies are disallowed when xfer granularity (x|y|z) is 0. Skipped.\n", kSkipPrefix);
1758 return;
1759 }
1760
sfricke-samsung6d97e562020-01-07 22:01:00 -08001761 // All VkImageObj must be defined here as if defined inside below scopes will cause image memory to be deleted when out of scope
1762 // 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 -07001763 VkImageObj image_64k(m_device); // 128^2 texels, 64k
1764 VkImageObj image_16k(m_device); // 64^2 texels, 16k
sfricke-samsung6d97e562020-01-07 22:01:00 -08001765 // depth stencil
unknown088160a2019-05-23 17:43:13 -06001766 VkImageObj image_16k_depth(m_device); // 64^2 texels, depth, 16k
1767 VkImageObj ds_image_4D_1S(m_device); // 256^2 texels, 512kb (256k depth, 64k stencil, 192k pack)
1768 VkImageObj ds_image_3D_1S(m_device); // 256^2 texels, 256kb (192k depth, 64k stencil)
1769 VkImageObj ds_image_2D(m_device); // 256^2 texels, 128k (128k depth)
1770 VkImageObj ds_image_1S(m_device); // 256^2 texels, 64k (64k stencil)
sfricke-samsung6d97e562020-01-07 22:01:00 -08001771 // compression
1772 VkImageObj image_16k_4x4comp(m_device); // 128^2 texels as 32^2 compressed (4x4) blocks, 16k
1773 VkImageObj image_NPOT_4x4comp(m_device); // 130^2 texels as 33^2 compressed (4x4) blocks
1774 // multi-planar
1775 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 -06001776
sfricke-samsung6d97e562020-01-07 22:01:00 -08001777 // Verify R8G8B8A8_UINT format is supported for transfer
1778 bool missing_rgba_support = false;
1779 VkFormatProperties props = {0, 0, 0};
1780 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_R8G8B8A8_UINT, &props);
1781 missing_rgba_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
1782 missing_rgba_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
1783 missing_rgba_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
1784
1785 if (!missing_rgba_support) {
1786 image_64k.Init(128, 128, 1, VK_FORMAT_R8G8B8A8_UINT,
1787 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1788 VK_IMAGE_TILING_OPTIMAL, 0);
1789 ASSERT_TRUE(image_64k.initialized());
1790
1791 image_16k.Init(64, 64, 1, VK_FORMAT_R8G8B8A8_UINT,
1792 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1793 VK_IMAGE_TILING_OPTIMAL, 0);
1794 ASSERT_TRUE(image_16k.initialized());
1795 }
unknown088160a2019-05-23 17:43:13 -06001796
1797 // Verify all needed Depth/Stencil formats are supported
1798 bool missing_ds_support = false;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001799 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001800 missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
1801 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
1802 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001803 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D24_UNORM_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001804 missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
1805 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
1806 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001807 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &props);
unknown088160a2019-05-23 17:43:13 -06001808 missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
1809 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
1810 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001811 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001812 missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
1813 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
1814 missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
1815
1816 if (!missing_ds_support) {
1817 image_16k_depth.Init(64, 64, 1, VK_FORMAT_D24_UNORM_S8_UINT,
1818 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
1819 ASSERT_TRUE(image_16k_depth.initialized());
1820
1821 ds_image_4D_1S.Init(
1822 256, 256, 1, VK_FORMAT_D32_SFLOAT_S8_UINT,
1823 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1824 VK_IMAGE_TILING_OPTIMAL, 0);
1825 ASSERT_TRUE(ds_image_4D_1S.initialized());
1826
1827 ds_image_3D_1S.Init(
1828 256, 256, 1, VK_FORMAT_D24_UNORM_S8_UINT,
1829 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1830 VK_IMAGE_TILING_OPTIMAL, 0);
1831 ASSERT_TRUE(ds_image_3D_1S.initialized());
1832
1833 ds_image_2D.Init(
1834 256, 256, 1, VK_FORMAT_D16_UNORM,
1835 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1836 VK_IMAGE_TILING_OPTIMAL, 0);
1837 ASSERT_TRUE(ds_image_2D.initialized());
1838
1839 ds_image_1S.Init(
1840 256, 256, 1, VK_FORMAT_S8_UINT,
1841 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1842 VK_IMAGE_TILING_OPTIMAL, 0);
1843 ASSERT_TRUE(ds_image_1S.initialized());
1844 }
1845
1846 // Allocate buffers
1847 VkBufferObj buffer_256k, buffer_128k, buffer_64k, buffer_16k;
1848 VkMemoryPropertyFlags reqs = 0;
1849 buffer_256k.init_as_src_and_dst(*m_device, 262144, reqs); // 256k
1850 buffer_128k.init_as_src_and_dst(*m_device, 131072, reqs); // 128k
1851 buffer_64k.init_as_src_and_dst(*m_device, 65536, reqs); // 64k
1852 buffer_16k.init_as_src_and_dst(*m_device, 16384, reqs); // 16k
1853
1854 VkBufferImageCopy region = {};
1855 region.bufferRowLength = 0;
1856 region.bufferImageHeight = 0;
1857 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1858 region.imageSubresource.layerCount = 1;
1859 region.imageOffset = {0, 0, 0};
1860 region.imageExtent = {64, 64, 1};
1861 region.bufferOffset = 0;
1862
locke-lunargdf00db02020-03-04 19:00:57 -07001863 VkMemoryBarrier mem_barriers[3];
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001864 mem_barriers[0] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001865 mem_barriers[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1866 mem_barriers[0].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001867 mem_barriers[1] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001868 mem_barriers[1].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1869 mem_barriers[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07001870 mem_barriers[2] = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07001871 mem_barriers[2].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
1872 mem_barriers[2].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
1873
sfricke-samsung6d97e562020-01-07 22:01:00 -08001874 if (missing_rgba_support) {
1875 printf("%s R8G8B8A8_UINT transfer unsupported - skipping RGBA tests.\n", kSkipPrefix);
unknown088160a2019-05-23 17:43:13 -06001876
sfricke-samsung6d97e562020-01-07 22:01:00 -08001877 // start recording for future tests
1878 m_commandBuffer->begin();
1879 } else {
1880 // attempt copies before putting command buffer in recording state
Mark Lobodzinski20310782020-02-28 14:25:17 -07001881 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-recording");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001882 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1883 &region);
unknown088160a2019-05-23 17:43:13 -06001884 m_errorMonitor->VerifyFound();
1885
Mark Lobodzinski20310782020-02-28 14:25:17 -07001886 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001887 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1,
1888 &region);
1889 m_errorMonitor->VerifyFound();
1890
1891 // start recording
1892 m_commandBuffer->begin();
1893
1894 // successful copies
sfricke-samsung6d97e562020-01-07 22:01:00 -08001895 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1896 &region);
locke-lunargdf00db02020-03-04 19:00:57 -07001897
1898 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1899 &mem_barriers[2], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001900 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1901 &region);
1902 region.imageOffset.x = 16; // 16k copy, offset requires larger image
locke-lunargdf00db02020-03-04 19:00:57 -07001903
1904 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1905 &mem_barriers[0], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001906 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1907 &region);
1908 region.imageExtent.height = 78; // > 16k copy requires larger buffer & image
locke-lunargdf00db02020-03-04 19:00:57 -07001909
1910 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
1911 &mem_barriers[1], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001912 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1913 &region);
1914 region.imageOffset.x = 0;
1915 region.imageExtent.height = 64;
1916 region.bufferOffset = 256; // 16k copy with buffer offset, requires larger buffer
locke-lunargdf00db02020-03-04 19:00:57 -07001917
1918 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 2,
1919 &mem_barriers[1], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001920 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1,
1921 &region);
sfricke-samsung6d97e562020-01-07 22:01:00 -08001922
1923 // image/buffer too small (extent too large) on copy to image
1924 region.imageExtent = {65, 64, 1};
Mark Lobodzinski20310782020-02-28 14:25:17 -07001925 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001926 "VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small
1927 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1928 &region);
1929 m_errorMonitor->VerifyFound();
1930
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001931 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-06218");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001932 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001933 "VUID-vkCmdCopyBufferToImage-pRegions-06217"); // image too small
sfricke-samsung6d97e562020-01-07 22:01:00 -08001934 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1935 &region);
1936 m_errorMonitor->VerifyFound();
1937
1938 // image/buffer too small (offset) on copy to image
1939 region.imageExtent = {64, 64, 1};
1940 region.imageOffset = {0, 4, 0};
Mark Lobodzinski20310782020-02-28 14:25:17 -07001941 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001942 "VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small
1943 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1944 &region);
1945 m_errorMonitor->VerifyFound();
1946
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001947 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-06218");
1948 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-06219");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001949 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001950 "VUID-vkCmdCopyBufferToImage-pRegions-06217"); // image too small
sfricke-samsung6d97e562020-01-07 22:01:00 -08001951 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1952 &region);
1953 m_errorMonitor->VerifyFound();
1954
1955 // image/buffer too small on copy to buffer
1956 region.imageExtent = {64, 64, 1};
1957 region.imageOffset = {0, 0, 0};
1958 region.bufferOffset = 4;
Mark Lobodzinski20310782020-02-28 14:25:17 -07001959 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001960 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // buffer too small
1961 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1962 &region);
1963 m_errorMonitor->VerifyFound();
1964
1965 region.imageExtent = {64, 65, 1};
1966 region.bufferOffset = 0;
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001967 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImageToBuffer-pRegions-06222");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001968 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07001969 "VUID-vkCmdCopyImageToBuffer-pRegions-06220"); // image too small
sfricke-samsung6d97e562020-01-07 22:01:00 -08001970 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1,
1971 &region);
1972 m_errorMonitor->VerifyFound();
1973
1974 // buffer size OK but rowlength causes loose packing
Mark Lobodzinski20310782020-02-28 14:25:17 -07001975 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001976 region.imageExtent = {64, 64, 1};
1977 region.bufferRowLength = 68;
1978 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1979 &region);
1980 m_errorMonitor->VerifyFound();
1981
sfricke-samsung5f11b0e2022-03-22 14:12:15 -05001982 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06659");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001983 region.imageExtent.width = 0;
sfricke-samsung5f11b0e2022-03-22 14:12:15 -05001984 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001985 &region);
1986 m_errorMonitor->VerifyFound();
1987
1988 // aspect bits
1989 region.imageExtent = {64, 64, 1};
1990 region.bufferRowLength = 0;
1991 region.bufferImageHeight = 0;
1992 if (!missing_ds_support) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07001993 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001994 "VUID-VkBufferImageCopy-aspectMask-00212"); // more than 1 aspect bit set
1995 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
1996 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL,
1997 buffer_16k.handle(), 1, &region);
1998 m_errorMonitor->VerifyFound();
1999
Mark Lobodzinski20310782020-02-28 14:25:17 -07002000 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002001 "VUID-vkCmdCopyImageToBuffer-aspectMask-00211"); // different mis-matched aspect
sfricke-samsung6d97e562020-01-07 22:01:00 -08002002 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2003 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL,
2004 buffer_16k.handle(), 1, &region);
2005 m_errorMonitor->VerifyFound();
2006 }
2007
Mark Lobodzinski20310782020-02-28 14:25:17 -07002008 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002009 "VUID-vkCmdCopyImageToBuffer-aspectMask-00211"); // mis-matched aspect
sfricke-samsung6d97e562020-01-07 22:01:00 -08002010 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
2011 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
2012 &region);
2013 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06002014 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
sfricke-samsung6d97e562020-01-07 22:01:00 -08002015
2016 // Out-of-range mip levels should fail
2017 region.imageSubresource.mipLevel = image_16k.create_info().mipLevels + 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002018 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703");
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07002019 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImageToBuffer-pRegions-06221");
2020 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImageToBuffer-pRegions-06222");
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002021 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImageToBuffer-imageOffset-00200");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002022 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002023 kErrorBit,
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07002024 "VUID-vkCmdCopyImageToBuffer-pRegions-06220"); // unavoidable "region exceeds image bounds" for non-existent mip
sfricke-samsung6d97e562020-01-07 22:01:00 -08002025 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
2026 &region);
2027 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07002028 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01701");
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07002029 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-06218");
2030 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-06219");
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002031 m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-imageOffset-00200");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002032 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002033 kErrorBit,
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07002034 "VUID-vkCmdCopyBufferToImage-pRegions-06217"); // unavoidable "region exceeds image bounds" for non-existent mip
sfricke-samsung6d97e562020-01-07 22:01:00 -08002035 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
2036 &region);
2037 m_errorMonitor->VerifyFound();
2038 region.imageSubresource.mipLevel = 0;
2039
2040 // Out-of-range array layers should fail
2041 region.imageSubresource.baseArrayLayer = image_16k.create_info().arrayLayers;
2042 region.imageSubresource.layerCount = 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002043 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002044 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
2045 &region);
2046 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07002047 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01702");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002048 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
2049 &region);
2050 m_errorMonitor->VerifyFound();
2051 region.imageSubresource.baseArrayLayer = 0;
2052
2053 // Layout mismatch should fail
Mark Lobodzinski20310782020-02-28 14:25:17 -07002054 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002055 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2056 buffer_16k.handle(), 1, &region);
2057 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07002058 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002059 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(),
2060 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06002061 m_errorMonitor->VerifyFound();
2062 }
2063
unknown088160a2019-05-23 17:43:13 -06002064 // Test Depth/Stencil copies
2065 if (missing_ds_support) {
2066 printf("%s Depth / Stencil formats unsupported - skipping D/S tests.\n", kSkipPrefix);
2067 } else {
2068 VkBufferImageCopy ds_region = {};
2069 ds_region.bufferOffset = 0;
2070 ds_region.bufferRowLength = 0;
2071 ds_region.bufferImageHeight = 0;
2072 ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
2073 ds_region.imageSubresource.mipLevel = 0;
2074 ds_region.imageSubresource.baseArrayLayer = 0;
2075 ds_region.imageSubresource.layerCount = 1;
2076 ds_region.imageOffset = {0, 0, 0};
2077 ds_region.imageExtent = {256, 256, 1};
2078
2079 // Depth copies that should succeed
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002080 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2081 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002082
locke-lunargdf00db02020-03-04 19:00:57 -07002083 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2084 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002085 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2086 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002087
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002088 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2089 buffer_128k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002090
2091 // Depth copies that should fail
2092 ds_region.bufferOffset = 4;
2093 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002094 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002095 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 4b depth per texel, pack into 256k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002096 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2097 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002098 m_errorMonitor->VerifyFound();
2099
2100 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002101 kErrorBit,
locke-lunarg00710512020-06-01 13:56:49 -06002102 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 3b depth per texel, pack (loose) into 128k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002103 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
locke-lunarg00710512020-06-01 13:56:49 -06002104 buffer_128k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002105 m_errorMonitor->VerifyFound();
2106
2107 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002108 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002109 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 2b depth per texel, into 128k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002110 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2111 buffer_128k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002112 m_errorMonitor->VerifyFound();
2113
sfricke-samsung5a019492021-01-25 10:32:08 -08002114 ds_region.bufferOffset = 5;
2115 ds_region.imageExtent = {64, 64, 1}; // need smaller so offset works
2116 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-srcImage-04053");
2117 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2118 buffer_128k.handle(), 1, &ds_region);
2119 m_errorMonitor->VerifyFound();
2120 ds_region.imageExtent = {256, 256, 1};
2121
unknown088160a2019-05-23 17:43:13 -06002122 // Stencil copies that should succeed
2123 ds_region.bufferOffset = 0;
2124 ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
locke-lunargdf00db02020-03-04 19:00:57 -07002125 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2126 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002127 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2128 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002129
locke-lunargdf00db02020-03-04 19:00:57 -07002130 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2131 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002132 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2133 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002134
locke-lunargdf00db02020-03-04 19:00:57 -07002135 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2136 &mem_barriers[0], 0, nullptr, 0, nullptr);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002137 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2138 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002139
2140 // Stencil copies that should fail
2141 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002142 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002143 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002144 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2145 buffer_16k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002146 m_errorMonitor->VerifyFound();
2147
2148 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002149 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002150 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
2151 ds_region.bufferRowLength = 260;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002152 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2153 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002154 m_errorMonitor->VerifyFound();
2155
2156 ds_region.bufferRowLength = 0;
2157 ds_region.bufferOffset = 4;
2158 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07002159 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002160 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 1b depth per texel, into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002161 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2162 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06002163 m_errorMonitor->VerifyFound();
2164 }
2165
2166 // Test compressed formats, if supported
sfricke-samsung6d97e562020-01-07 22:01:00 -08002167 // Support here requires both feature bit for compression and picked format supports transfer feature bits
unknown088160a2019-05-23 17:43:13 -06002168 VkPhysicalDeviceFeatures device_features = {};
2169 ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
2170 if (!(device_features.textureCompressionBC || device_features.textureCompressionETC2 ||
2171 device_features.textureCompressionASTC_LDR)) {
2172 printf("%s No compressed formats supported - block compression tests skipped.\n", kSkipPrefix);
2173 } else {
sfricke-samsung6d97e562020-01-07 22:01:00 -08002174 // Verify transfer support for each compression format used blow
2175 bool missing_bc_support = false;
2176 bool missing_etc_support = false;
2177 bool missing_astc_support = false;
2178 bool missing_compression_support = false;
2179
2180 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_BC3_SRGB_BLOCK, &props);
2181 missing_bc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
2182 missing_bc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
2183 missing_bc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
2184
2185 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, &props);
2186 missing_etc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
2187 missing_etc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
2188 missing_etc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
2189
2190 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_ASTC_4x4_UNORM_BLOCK, &props);
2191 missing_astc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
2192 missing_astc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
2193 missing_astc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
2194
2195 if (device_features.textureCompressionBC && (!missing_bc_support)) {
unknown088160a2019-05-23 17:43:13 -06002196 image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL,
2197 0);
2198 image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL,
2199 0);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002200 } else if (device_features.textureCompressionETC2 && (!missing_etc_support)) {
unknown088160a2019-05-23 17:43:13 -06002201 image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2202 VK_IMAGE_TILING_OPTIMAL, 0);
2203 image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2204 VK_IMAGE_TILING_OPTIMAL, 0);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002205 } else if (device_features.textureCompressionASTC_LDR && (!missing_astc_support)) {
unknown088160a2019-05-23 17:43:13 -06002206 image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2207 VK_IMAGE_TILING_OPTIMAL, 0);
2208 image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2209 VK_IMAGE_TILING_OPTIMAL, 0);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002210 } else {
2211 missing_compression_support = true;
unknown088160a2019-05-23 17:43:13 -06002212 }
unknown088160a2019-05-23 17:43:13 -06002213
sfricke-samsung6d97e562020-01-07 22:01:00 -08002214 if (missing_compression_support) {
2215 printf("%s No compressed formats transfers bits are supported - block compression tests skipped.\n", kSkipPrefix);
2216 } else {
2217 ASSERT_TRUE(image_16k_4x4comp.initialized());
sfricke-samsung3a10b922020-05-13 23:23:16 -07002218 std::string vuid;
sfricke-samsung6d97e562020-01-07 22:01:00 -08002219 // Just fits
locke-lunargdf00db02020-03-04 19:00:57 -07002220 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2221 &mem_barriers[0], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002222 region.imageExtent = {128, 128, 1};
2223 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2224 buffer_16k.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06002225
sfricke-samsung6d97e562020-01-07 22:01:00 -08002226 // with offset, too big for buffer
Mark Lobodzinski20310782020-02-28 14:25:17 -07002227 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002228 region.bufferOffset = 16;
2229 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2230 buffer_16k.handle(), 1, &region);
2231 m_errorMonitor->VerifyFound();
2232 region.bufferOffset = 0;
unknown088160a2019-05-23 17:43:13 -06002233
sfricke-samsung6d97e562020-01-07 22:01:00 -08002234 // extents that are not a multiple of compressed block size
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002235 m_errorMonitor->SetDesiredFailureMsg(
2236 kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageExtent-00207"); // extent width not a multiple of block size
Mark Lobodzinski20310782020-02-28 14:25:17 -07002237 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08002238 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
2239 region.imageExtent.width = 66;
2240 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2241 buffer_16k.handle(), 1, &region);
2242 m_errorMonitor->VerifyFound();
2243 region.imageExtent.width = 128;
unknown088160a2019-05-23 17:43:13 -06002244
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002245 m_errorMonitor->SetDesiredFailureMsg(
2246 kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageExtent-00208"); // extent height not a multiple of block size
Mark Lobodzinski20310782020-02-28 14:25:17 -07002247 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08002248 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
2249 region.imageExtent.height = 2;
2250 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2251 buffer_16k.handle(), 1, &region);
2252 m_errorMonitor->VerifyFound();
2253 region.imageExtent.height = 128;
unknown088160a2019-05-23 17:43:13 -06002254
sfricke-samsung6d97e562020-01-07 22:01:00 -08002255 // TODO: All available compressed formats are 2D, with block depth of 1. Unable to provoke VU_01277.
unknown088160a2019-05-23 17:43:13 -06002256
sfricke-samsung6d97e562020-01-07 22:01:00 -08002257 // non-multiple extents are allowed if at the far edge of a non-block-multiple image - these should pass
sfricke-samsung6d97e562020-01-07 22:01:00 -08002258 region.imageExtent.width = 66;
2259 region.imageOffset.x = 64;
locke-lunargdf00db02020-03-04 19:00:57 -07002260 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2261 &mem_barriers[0], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002262 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2263 buffer_16k.handle(), 1, &region);
2264 region.imageExtent.width = 16;
2265 region.imageOffset.x = 0;
2266 region.imageExtent.height = 2;
2267 region.imageOffset.y = 128;
locke-lunargdf00db02020-03-04 19:00:57 -07002268 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2269 &mem_barriers[0], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002270 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2271 buffer_16k.handle(), 1, &region);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002272 region.imageOffset = {0, 0, 0};
unknown088160a2019-05-23 17:43:13 -06002273
sfricke-samsung6d97e562020-01-07 22:01:00 -08002274 // buffer offset must be a multiple of texel block size (16)
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002275 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-bufferOffset-00206");
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002276 vuid =
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002277 mp_extensions ? "VUID-vkCmdCopyImageToBuffer-bufferOffset-01558" : "VUID-vkCmdCopyImageToBuffer-bufferOffset-00193";
sfricke-samsung125d2b42020-05-28 06:32:43 -07002278 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002279 region.imageExtent = {64, 64, 1};
2280 region.bufferOffset = 24;
2281 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2282 buffer_16k.handle(), 1, &region);
2283 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06002284
sfricke-samsung6d97e562020-01-07 22:01:00 -08002285 // rowlength not a multiple of block width (4)
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002286 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-bufferRowLength-00203");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002287 region.bufferOffset = 0;
2288 region.bufferRowLength = 130;
2289 region.bufferImageHeight = 0;
2290 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2291 buffer_64k.handle(), 1, &region);
2292 m_errorMonitor->VerifyFound();
2293
2294 // imageheight not a multiple of block height (4)
sfricke-samsung88ac6fe2020-10-24 10:00:13 -07002295 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-bufferImageHeight-00204");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002296 region.bufferRowLength = 0;
2297 region.bufferImageHeight = 130;
2298 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2299 buffer_64k.handle(), 1, &region);
2300 m_errorMonitor->VerifyFound();
2301 }
2302 }
2303
2304 // Test multi-planar formats, if supported
2305 if (!mp_extensions) {
2306 printf("%s multi-planar extensions not supported; skipped.\n", kSkipPrefix);
2307 } else {
2308 // Try to use G8_B8R8_2PLANE_420_UNORM because need 2-plane format for some tests and likely supported due to copy support
2309 // being required with samplerYcbcrConversion feature
2310 bool missing_mp_support = false;
2311 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &props);
2312 missing_mp_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
2313 missing_mp_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
2314 missing_mp_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
2315
2316 if (missing_mp_support) {
2317 printf("%s VK_FORMAT_G8_B8R8_2PLANE_420_UNORM transfer not supported; skipped.\n", kSkipPrefix);
2318 } else {
2319 VkBufferImageCopy mp_region = {};
2320 mp_region.bufferOffset = 0;
2321 mp_region.bufferRowLength = 0;
2322 mp_region.bufferImageHeight = 0;
2323 mp_region.imageSubresource.mipLevel = 0;
2324 mp_region.imageSubresource.baseArrayLayer = 0;
2325 mp_region.imageSubresource.layerCount = 1;
2326 mp_region.imageOffset = {0, 0, 0};
2327 mp_region.imageExtent = {128, 128, 1};
2328
2329 // YUV420 means 1/2 width and height so plane_0 is 128x128 and plane_1 is 64x64 here
2330 image_multi_planar.Init(128, 128, 1, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT,
2331 VK_IMAGE_TILING_OPTIMAL, 0);
2332 ASSERT_TRUE(image_multi_planar.initialized());
2333
2334 // Copies into a mutli-planar image aspect properly
sfricke-samsung6d97e562020-01-07 22:01:00 -08002335 mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
locke-lunargdf00db02020-03-04 19:00:57 -07002336 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
2337 &mem_barriers[2], 0, nullptr, 0, nullptr);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002338 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(),
2339 VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002340
2341 // uses plane_2 without being 3 planar format
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002342 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-aspectMask-01560");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002343 mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT;
2344 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(),
2345 VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region);
2346 m_errorMonitor->VerifyFound();
2347
2348 // uses single-plane aspect mask
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002349 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-aspectMask-01560");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002350 mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2351 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(),
2352 VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region);
2353 m_errorMonitor->VerifyFound();
sfricke-samsungb616d3f2020-06-03 22:00:34 -07002354
2355 // buffer offset must be a multiple of texel block size for VK_FORMAT_R8G8_UNORM (2)
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002356 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-bufferOffset-01559");
sfricke-samsungb616d3f2020-06-03 22:00:34 -07002357 mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
2358 mp_region.bufferOffset = 5;
2359 mp_region.imageExtent = {8, 8, 1};
2360 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(),
2361 VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region);
2362 m_errorMonitor->VerifyFound();
sfricke-samsung6d97e562020-01-07 22:01:00 -08002363 }
unknown088160a2019-05-23 17:43:13 -06002364 }
2365}
2366
2367TEST_F(VkLayerTest, MiscImageLayerTests) {
2368 TEST_DESCRIPTION("Image-related tests that don't belong elsewhere");
2369
2370 ASSERT_NO_FATAL_FAILURE(Init());
2371
2372 // TODO: Ideally we should check if a format is supported, before using it.
2373 VkImageObj image(m_device);
2374 image.Init(128, 128, 1, VK_FORMAT_R16G16B16A16_UINT, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 64bpp
2375 ASSERT_TRUE(image.initialized());
2376 VkBufferObj buffer;
2377 VkMemoryPropertyFlags reqs = 0;
2378 buffer.init_as_src(*m_device, 128 * 128 * 8, reqs);
2379 VkBufferImageCopy region = {};
2380 region.bufferRowLength = 128;
2381 region.bufferImageHeight = 128;
2382 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2383 // layerCount can't be 0 - Expect MISMATCHED_IMAGE_ASPECT
2384 region.imageSubresource.layerCount = 1;
2385 region.imageExtent.height = 4;
2386 region.imageExtent.width = 4;
2387 region.imageExtent.depth = 1;
2388
2389 VkImageObj image2(m_device);
2390 image2.Init(128, 128, 1, VK_FORMAT_R8G8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 16bpp
2391 ASSERT_TRUE(image2.initialized());
2392 VkBufferObj buffer2;
2393 VkMemoryPropertyFlags reqs2 = 0;
2394 buffer2.init_as_src(*m_device, 128 * 128 * 2, reqs2);
unknown088160a2019-05-23 17:43:13 -06002395 m_commandBuffer->begin();
2396
2397 // Image must have offset.z of 0 and extent.depth of 1
2398 // Introduce failure by setting imageExtent.depth to 0
2399 region.imageExtent.depth = 0;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002400 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-srcImage-00201");
sfricke-samsung5f11b0e2022-03-22 14:12:15 -05002401 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06661");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002402 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2403 &region);
unknown088160a2019-05-23 17:43:13 -06002404 m_errorMonitor->VerifyFound();
2405
2406 region.imageExtent.depth = 1;
2407
2408 // Image must have offset.z of 0 and extent.depth of 1
2409 // Introduce failure by setting imageOffset.z to 4
2410 // Note: Also (unavoidably) triggers 'region exceeds image' #1228
2411 region.imageOffset.z = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002412 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-srcImage-00201");
2413 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageOffset-00200");
Mike Schuchardt7b152fa2021-08-03 16:30:27 -07002414 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-06217");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002415 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2416 &region);
unknown088160a2019-05-23 17:43:13 -06002417 m_errorMonitor->VerifyFound();
2418
2419 region.imageOffset.z = 0;
2420 // BufferOffset must be a multiple of the calling command's VkImage parameter's texel size
2421 // Introduce failure by setting bufferOffset to 1 and 1/2 texels
2422 region.bufferOffset = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002423 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-bufferOffset-00193");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002424 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2425 &region);
unknown088160a2019-05-23 17:43:13 -06002426 m_errorMonitor->VerifyFound();
2427
unknown088160a2019-05-23 17:43:13 -06002428 // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent
2429 region.bufferOffset = 0;
2430 region.imageExtent.height = 128;
2431 region.imageExtent.width = 128;
2432 // Introduce failure by setting bufferRowLength > 0 but less than width
2433 region.bufferRowLength = 64;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002434 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferRowLength-00195");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002435 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2436 &region);
unknown088160a2019-05-23 17:43:13 -06002437 m_errorMonitor->VerifyFound();
2438
2439 // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
2440 region.bufferRowLength = 128;
2441 // Introduce failure by setting bufferRowHeight > 0 but less than height
2442 region.bufferImageHeight = 64;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002443 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferImageHeight-00196");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002444 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2445 &region);
unknown088160a2019-05-23 17:43:13 -06002446 m_errorMonitor->VerifyFound();
2447
2448 region.bufferImageHeight = 128;
2449 VkImageObj intImage1(m_device);
2450 intImage1.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
2451 intImage1.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
2452 VkImageObj intImage2(m_device);
2453 intImage2.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
2454 intImage2.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
2455 VkImageBlit blitRegion = {};
2456 blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2457 blitRegion.srcSubresource.baseArrayLayer = 0;
2458 blitRegion.srcSubresource.layerCount = 1;
2459 blitRegion.srcSubresource.mipLevel = 0;
2460 blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2461 blitRegion.dstSubresource.baseArrayLayer = 0;
2462 blitRegion.dstSubresource.layerCount = 1;
2463 blitRegion.dstSubresource.mipLevel = 0;
2464 blitRegion.srcOffsets[0] = {128, 0, 0};
2465 blitRegion.srcOffsets[1] = {128, 128, 1};
2466 blitRegion.dstOffsets[0] = {0, 128, 0};
2467 blitRegion.dstOffsets[1] = {128, 128, 1};
2468
2469 // Look for NULL-blit warning
sfricke-samsung85584a72021-09-30 21:43:38 -07002470 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdBlitImage: pRegions[0].srcOffsets specify a zero-volume area.");
2471 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdBlitImage: pRegions[0].dstOffsets specify a zero-volume area.");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002472 vk::CmdBlitImage(m_commandBuffer->handle(), intImage1.handle(), intImage1.Layout(), intImage2.handle(), intImage2.Layout(), 1,
2473 &blitRegion, VK_FILTER_LINEAR);
unknown088160a2019-05-23 17:43:13 -06002474 m_errorMonitor->VerifyFound();
2475}
2476
2477TEST_F(VkLayerTest, CopyImageTypeExtentMismatch) {
2478 // Image copy tests where format type and extents don't match
Jeff Leger465acf52020-10-12 18:07:16 -04002479 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
2480
2481 bool copy_commands2 = false;
2482 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME)) {
2483 m_device_extension_names.push_back(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME);
2484 copy_commands2 = true;
2485 }
2486 ASSERT_NO_FATAL_FAILURE(InitState());
2487
2488 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2Function = nullptr;
2489 if (copy_commands2) {
2490 vkCmdCopyImage2Function = (PFN_vkCmdCopyImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdCopyImage2KHR");
2491 }
unknown088160a2019-05-23 17:43:13 -06002492
sfricke-samsung30b094c2020-05-30 11:42:11 -07002493 // Tests are designed to run without Maintenance1 which was promoted in 1.1
2494 if (DeviceValidationVersion() >= VK_API_VERSION_1_1) {
sjfricke50955f32022-06-05 10:12:52 +09002495 GTEST_SKIP() << "Tests for 1.0 only";
sfricke-samsung30b094c2020-05-30 11:42:11 -07002496 }
2497
sfricke-samsung1c61f192021-12-31 01:53:03 -06002498 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06002499 ci.flags = 0;
2500 ci.imageType = VK_IMAGE_TYPE_1D;
2501 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
2502 ci.extent = {32, 1, 1};
2503 ci.mipLevels = 1;
2504 ci.arrayLayers = 1;
2505 ci.samples = VK_SAMPLE_COUNT_1_BIT;
2506 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
2507 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2508 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
2509 ci.queueFamilyIndexCount = 0;
2510 ci.pQueueFamilyIndices = NULL;
2511 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
2512
2513 // Create 1D image
2514 VkImageObj image_1D(m_device);
2515 image_1D.init(&ci);
2516 ASSERT_TRUE(image_1D.initialized());
2517
2518 // 2D image
2519 ci.imageType = VK_IMAGE_TYPE_2D;
2520 ci.extent = {32, 32, 1};
2521 VkImageObj image_2D(m_device);
2522 image_2D.init(&ci);
2523 ASSERT_TRUE(image_2D.initialized());
2524
2525 // 3D image
2526 ci.imageType = VK_IMAGE_TYPE_3D;
2527 ci.extent = {32, 32, 8};
2528 VkImageObj image_3D(m_device);
2529 image_3D.init(&ci);
2530 ASSERT_TRUE(image_3D.initialized());
2531
2532 // 2D image array
2533 ci.imageType = VK_IMAGE_TYPE_2D;
2534 ci.extent = {32, 32, 1};
2535 ci.arrayLayers = 8;
2536 VkImageObj image_2D_array(m_device);
2537 image_2D_array.init(&ci);
2538 ASSERT_TRUE(image_2D_array.initialized());
2539
2540 m_commandBuffer->begin();
2541
2542 VkImageCopy copy_region;
2543 copy_region.extent = {32, 1, 1};
2544 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2545 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2546 copy_region.srcSubresource.mipLevel = 0;
2547 copy_region.dstSubresource.mipLevel = 0;
2548 copy_region.srcSubresource.baseArrayLayer = 0;
2549 copy_region.dstSubresource.baseArrayLayer = 0;
2550 copy_region.srcSubresource.layerCount = 1;
2551 copy_region.dstSubresource.layerCount = 1;
2552 copy_region.srcOffset = {0, 0, 0};
2553 copy_region.dstOffset = {0, 0, 0};
2554
2555 // Sanity check
unknown088160a2019-05-23 17:43:13 -06002556 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2557 &copy_region);
unknown088160a2019-05-23 17:43:13 -06002558
Jeff Leger465acf52020-10-12 18:07:16 -04002559 // Equivalent sanity check using KHR_copy_commands2
2560 if (copy_commands2 && vkCmdCopyImage2Function) {
2561 const VkImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
2562 NULL,
2563 copy_region.srcSubresource,
2564 copy_region.srcOffset,
2565 copy_region.dstSubresource,
2566 copy_region.dstOffset,
2567 copy_region.extent};
2568 const VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
2569 NULL,
2570 image_1D.image(),
2571 VK_IMAGE_LAYOUT_GENERAL,
2572 image_2D.image(),
2573 VK_IMAGE_LAYOUT_GENERAL,
2574 1,
2575 &region2};
Jeff Leger465acf52020-10-12 18:07:16 -04002576 vkCmdCopyImage2Function(m_commandBuffer->handle(), &copy_image_info2);
Jeff Leger465acf52020-10-12 18:07:16 -04002577 }
2578
unknown088160a2019-05-23 17:43:13 -06002579 // 1D texture w/ offset.y > 0. Source = VU 09c00124, dest = 09c00130
2580 copy_region.srcOffset.y = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002581 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00146");
2582 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00145"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002583 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2584 &copy_region);
2585 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04002586
2587 // Equivalent test using KHR_copy_commands2
2588 if (copy_commands2 && vkCmdCopyImage2Function) {
2589 const VkImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
2590 NULL,
2591 copy_region.srcSubresource,
2592 copy_region.srcOffset,
2593 copy_region.dstSubresource,
2594 copy_region.dstOffset,
2595 copy_region.extent};
2596 const VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
2597 NULL,
2598 image_1D.image(),
2599 VK_IMAGE_LAYOUT_GENERAL,
2600 image_2D.image(),
2601 VK_IMAGE_LAYOUT_GENERAL,
2602 1,
2603 &region2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07002604 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcImage-00146");
2605 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcOffset-00145"); // also y-dim overrun
Jeff Leger465acf52020-10-12 18:07:16 -04002606 vkCmdCopyImage2Function(m_commandBuffer->handle(), &copy_image_info2);
2607 m_errorMonitor->VerifyFound();
2608 }
2609
unknown088160a2019-05-23 17:43:13 -06002610 copy_region.srcOffset.y = 0;
2611 copy_region.dstOffset.y = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002612 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-00152");
2613 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00151"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002614 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2615 &copy_region);
2616 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04002617
2618 // Equivalent test using KHR_copy_commands2
2619 if (copy_commands2 && vkCmdCopyImage2Function) {
2620 const VkImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
2621 NULL,
2622 copy_region.srcSubresource,
2623 copy_region.srcOffset,
2624 copy_region.dstSubresource,
2625 copy_region.dstOffset,
2626 copy_region.extent};
2627 const VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
2628 NULL,
2629 image_2D.image(),
2630 VK_IMAGE_LAYOUT_GENERAL,
2631 image_1D.image(),
2632 VK_IMAGE_LAYOUT_GENERAL,
2633 1,
2634 &region2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07002635 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstImage-00152");
2636 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstOffset-00151"); // also y-dim overrun
Jeff Leger465acf52020-10-12 18:07:16 -04002637 vkCmdCopyImage2Function(m_commandBuffer->handle(), &copy_image_info2);
2638 m_errorMonitor->VerifyFound();
2639 }
2640
unknown088160a2019-05-23 17:43:13 -06002641 copy_region.dstOffset.y = 0;
2642
2643 // 1D texture w/ extent.height > 1. Source = VU 09c00124, dest = 09c00130
2644 copy_region.extent.height = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002645 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00146");
2646 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00145"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002647 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2648 &copy_region);
2649 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04002650
2651 // Equivalent test using KHR_copy_commands2
2652 if (copy_commands2 && vkCmdCopyImage2Function) {
2653 const VkImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
2654 NULL,
2655 copy_region.srcSubresource,
2656 copy_region.srcOffset,
2657 copy_region.dstSubresource,
2658 copy_region.dstOffset,
2659 copy_region.extent};
2660 const VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
2661 NULL,
2662 image_1D.image(),
2663 VK_IMAGE_LAYOUT_GENERAL,
2664 image_2D.image(),
2665 VK_IMAGE_LAYOUT_GENERAL,
2666 1,
2667 &region2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07002668 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcImage-00146");
2669 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcOffset-00145"); // also y-dim overrun
Jeff Leger465acf52020-10-12 18:07:16 -04002670 vkCmdCopyImage2Function(m_commandBuffer->handle(), &copy_image_info2);
2671 m_errorMonitor->VerifyFound();
2672 }
2673
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002674 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-00152");
2675 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00151"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002676 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2677 &copy_region);
2678 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04002679
2680 // Equivalent test using KHR_copy_commands2
2681 if (copy_commands2 && vkCmdCopyImage2Function) {
2682 const VkImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR,
2683 NULL,
2684 copy_region.srcSubresource,
2685 copy_region.srcOffset,
2686 copy_region.dstSubresource,
2687 copy_region.dstOffset,
2688 copy_region.extent};
2689 const VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR,
2690 NULL,
2691 image_2D.image(),
2692 VK_IMAGE_LAYOUT_GENERAL,
2693 image_1D.image(),
2694 VK_IMAGE_LAYOUT_GENERAL,
2695 1,
2696 &region2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07002697 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstImage-00152");
2698 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstOffset-00151"); // also y-dim overrun
Jeff Leger465acf52020-10-12 18:07:16 -04002699 vkCmdCopyImage2Function(m_commandBuffer->handle(), &copy_image_info2);
2700 m_errorMonitor->VerifyFound();
2701 }
2702
unknown088160a2019-05-23 17:43:13 -06002703 copy_region.extent.height = 1;
2704
2705 // 1D texture w/ offset.z > 0. Source = VU 09c00df2, dest = 09c00df4
2706 copy_region.srcOffset.z = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002707 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01785");
2708 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00147"); // also z-dim overrun
unknown088160a2019-05-23 17:43:13 -06002709 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2710 &copy_region);
2711 m_errorMonitor->VerifyFound();
2712 copy_region.srcOffset.z = 0;
2713 copy_region.dstOffset.z = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002714 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01786");
2715 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00153"); // also z-dim overrun
unknown088160a2019-05-23 17:43:13 -06002716 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2717 &copy_region);
2718 m_errorMonitor->VerifyFound();
2719 copy_region.dstOffset.z = 0;
2720
2721 // 1D texture w/ extent.depth > 1. Source = VU 09c00df2, dest = 09c00df4
2722 copy_region.extent.depth = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002723 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01785");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002724 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002725 "VUID-vkCmdCopyImage-srcOffset-00147"); // also z-dim overrun (src)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002726 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002727 "VUID-vkCmdCopyImage-dstOffset-00153"); // also z-dim overrun (dst)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002729 "VUID-vkCmdCopyImage-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1
unknown088160a2019-05-23 17:43:13 -06002730 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2731 &copy_region);
2732 m_errorMonitor->VerifyFound();
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002733 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01786");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002734 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002735 "VUID-vkCmdCopyImage-srcOffset-00147"); // also z-dim overrun (src)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002736 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002737 "VUID-vkCmdCopyImage-dstOffset-00153"); // also z-dim overrun (dst)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002738 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002739 "VUID-vkCmdCopyImage-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1
unknown088160a2019-05-23 17:43:13 -06002740 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2741 &copy_region);
2742 m_errorMonitor->VerifyFound();
2743 copy_region.extent.depth = 1;
2744
2745 // 2D texture w/ offset.z > 0. Source = VU 09c00df6, dest = 09c00df8
2746 copy_region.extent = {16, 16, 1};
2747 copy_region.srcOffset.z = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002748 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01787");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002749 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002750 "VUID-vkCmdCopyImage-srcOffset-00147"); // also z-dim overrun (src)
unknown088160a2019-05-23 17:43:13 -06002751 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2752 &copy_region);
2753 m_errorMonitor->VerifyFound();
2754 copy_region.srcOffset.z = 0;
2755 copy_region.dstOffset.z = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002756 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01788");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002757 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002758 "VUID-vkCmdCopyImage-dstOffset-00153"); // also z-dim overrun (dst)
unknown088160a2019-05-23 17:43:13 -06002759 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2760 &copy_region);
2761 m_errorMonitor->VerifyFound();
2762 copy_region.dstOffset.z = 0;
2763
2764 // 3D texture accessing an array layer other than 0. VU 09c0011a
2765 copy_region.extent = {4, 4, 1};
2766 copy_region.srcSubresource.baseArrayLayer = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002767 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00139");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002768 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002769 "VUID-vkCmdCopyImage-srcSubresource-01698"); // also 'too many layers'
2770 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2771 &copy_region);
2772 m_errorMonitor->VerifyFound();
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002773 copy_region.srcSubresource.baseArrayLayer = 0;
2774
unknown088160a2019-05-23 17:43:13 -06002775 m_commandBuffer->end();
2776}
2777
2778TEST_F(VkLayerTest, CopyImageTypeExtentMismatchMaintenance1) {
2779 // Image copy tests where format type and extents don't match and the Maintenance1 extension is enabled
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07002780 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07002781 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME)) {
2782 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06002783 } else {
2784 printf("%s Maintenance1 extension cannot be enabled, test skipped.\n", kSkipPrefix);
2785 return;
2786 }
2787 ASSERT_NO_FATAL_FAILURE(InitState());
2788
2789 VkFormat image_format = VK_FORMAT_R8G8B8A8_UNORM;
2790 VkFormatProperties format_props;
2791 // TODO: Remove this check if or when devsim handles extensions.
2792 // The chosen format has mandatory support the transfer src and dst format features when Maitenance1 is enabled. However, our
2793 // use of devsim and the mock ICD violate this guarantee.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002794 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props);
unknown088160a2019-05-23 17:43:13 -06002795 if (!(format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) {
2796 printf("%s Maintenance1 extension is not supported.\n", kSkipPrefix);
2797 return;
2798 }
2799
sfricke-samsung1c61f192021-12-31 01:53:03 -06002800 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06002801 ci.flags = 0;
2802 ci.imageType = VK_IMAGE_TYPE_1D;
2803 ci.format = image_format;
2804 ci.extent = {32, 1, 1};
2805 ci.mipLevels = 1;
2806 ci.arrayLayers = 1;
2807 ci.samples = VK_SAMPLE_COUNT_1_BIT;
2808 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
2809 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2810 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
2811 ci.queueFamilyIndexCount = 0;
2812 ci.pQueueFamilyIndices = NULL;
2813 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
2814
2815 // Create 1D image
2816 VkImageObj image_1D(m_device);
2817 image_1D.init(&ci);
2818 ASSERT_TRUE(image_1D.initialized());
2819
2820 // 2D image
2821 ci.imageType = VK_IMAGE_TYPE_2D;
2822 ci.extent = {32, 32, 1};
2823 VkImageObj image_2D(m_device);
2824 image_2D.init(&ci);
2825 ASSERT_TRUE(image_2D.initialized());
2826
2827 // 3D image
2828 ci.imageType = VK_IMAGE_TYPE_3D;
2829 ci.extent = {32, 32, 8};
2830 VkImageObj image_3D(m_device);
2831 image_3D.init(&ci);
2832 ASSERT_TRUE(image_3D.initialized());
2833
2834 // 2D image array
2835 ci.imageType = VK_IMAGE_TYPE_2D;
2836 ci.extent = {32, 32, 1};
2837 ci.arrayLayers = 8;
2838 VkImageObj image_2D_array(m_device);
2839 image_2D_array.init(&ci);
2840 ASSERT_TRUE(image_2D_array.initialized());
2841
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002842 // second 2D image array
2843 ci.imageType = VK_IMAGE_TYPE_2D;
2844 ci.extent = {32, 32, 1};
2845 ci.arrayLayers = 8;
2846 VkImageObj image_2D_array_2(m_device);
2847 image_2D_array_2.init(&ci);
2848 ASSERT_TRUE(image_2D_array_2.initialized());
2849
unknown088160a2019-05-23 17:43:13 -06002850 m_commandBuffer->begin();
2851
2852 VkImageCopy copy_region;
2853 copy_region.extent = {32, 1, 1};
2854 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2855 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2856 copy_region.srcSubresource.mipLevel = 0;
2857 copy_region.dstSubresource.mipLevel = 0;
2858 copy_region.srcSubresource.baseArrayLayer = 0;
2859 copy_region.dstSubresource.baseArrayLayer = 0;
2860 copy_region.srcSubresource.layerCount = 1;
2861 copy_region.dstSubresource.layerCount = 1;
2862 copy_region.srcOffset = {0, 0, 0};
2863 copy_region.dstOffset = {0, 0, 0};
2864
2865 // Copy from layer not present
2866 copy_region.srcSubresource.baseArrayLayer = 4;
2867 copy_region.srcSubresource.layerCount = 6;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002868 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcSubresource-01698");
unknown088160a2019-05-23 17:43:13 -06002869 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2870 &copy_region);
2871 m_errorMonitor->VerifyFound();
2872 copy_region.srcSubresource.baseArrayLayer = 0;
2873 copy_region.srcSubresource.layerCount = 1;
2874
2875 // Copy to layer not present
2876 copy_region.dstSubresource.baseArrayLayer = 1;
2877 copy_region.dstSubresource.layerCount = 8;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002878 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstSubresource-01699");
unknown088160a2019-05-23 17:43:13 -06002879 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2880 &copy_region);
2881 m_errorMonitor->VerifyFound();
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002882 copy_region.dstSubresource.baseArrayLayer = 0;
unknown088160a2019-05-23 17:43:13 -06002883 copy_region.dstSubresource.layerCount = 1;
2884
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002885 // both 2D and extent.depth not 1
2886 // Need two 2D array images to prevent other errors
2887 copy_region.extent = {4, 1, 2};
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002888 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01790");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002889 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array_2.image(), VK_IMAGE_LAYOUT_GENERAL,
2890 1, &copy_region);
2891 m_errorMonitor->VerifyFound();
2892 copy_region.extent = {32, 1, 1};
2893
2894 // 2D src / 3D dst and depth not equal to src layerCount
2895 copy_region.extent = {4, 1, 2};
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002896 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01791");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002897 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002898 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2899 &copy_region);
2900 m_errorMonitor->VerifyFound();
2901 copy_region.extent = {32, 1, 1};
2902
2903 // 3D src / 2D dst and depth not equal to dst layerCount
2904 copy_region.extent = {4, 1, 2};
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002905 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01792");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002906 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002907 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2908 &copy_region);
2909 m_errorMonitor->VerifyFound();
2910 copy_region.extent = {32, 1, 1};
2911
unknown088160a2019-05-23 17:43:13 -06002912 m_commandBuffer->end();
2913}
2914
2915TEST_F(VkLayerTest, CopyImageCompressedBlockAlignment) {
2916 // Image copy tests on compressed images with block alignment errors
2917 SetTargetApiVersion(VK_API_VERSION_1_1);
2918 ASSERT_NO_FATAL_FAILURE(Init());
2919
2920 // Select a compressed format and verify support
2921 VkPhysicalDeviceFeatures device_features = {};
2922 ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
2923 VkFormat compressed_format = VK_FORMAT_UNDEFINED;
2924 if (device_features.textureCompressionBC) {
2925 compressed_format = VK_FORMAT_BC3_SRGB_BLOCK;
2926 } else if (device_features.textureCompressionETC2) {
2927 compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
2928 } else if (device_features.textureCompressionASTC_LDR) {
2929 compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
2930 }
2931
sfricke-samsung1c61f192021-12-31 01:53:03 -06002932 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06002933 ci.flags = 0;
2934 ci.imageType = VK_IMAGE_TYPE_2D;
2935 ci.format = compressed_format;
2936 ci.extent = {64, 64, 1};
2937 ci.mipLevels = 1;
2938 ci.arrayLayers = 1;
2939 ci.samples = VK_SAMPLE_COUNT_1_BIT;
2940 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
2941 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2942 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
2943 ci.queueFamilyIndexCount = 0;
2944 ci.pQueueFamilyIndices = NULL;
2945 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
2946
2947 VkImageFormatProperties img_prop = {};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002948 if (VK_SUCCESS != vk::GetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), ci.format, ci.imageType, ci.tiling,
2949 ci.usage, ci.flags, &img_prop)) {
unknown088160a2019-05-23 17:43:13 -06002950 printf("%s No compressed formats supported - CopyImageCompressedBlockAlignment skipped.\n", kSkipPrefix);
2951 return;
2952 }
2953
2954 // Create images
2955 VkImageObj image_1(m_device);
2956 image_1.init(&ci);
2957 ASSERT_TRUE(image_1.initialized());
2958
2959 ci.extent = {62, 62, 1}; // slightly smaller and not divisible by block size
2960 VkImageObj image_2(m_device);
2961 image_2.init(&ci);
2962 ASSERT_TRUE(image_2.initialized());
2963
2964 m_commandBuffer->begin();
2965
2966 VkImageCopy copy_region;
2967 copy_region.extent = {48, 48, 1};
2968 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2969 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2970 copy_region.srcSubresource.mipLevel = 0;
2971 copy_region.dstSubresource.mipLevel = 0;
2972 copy_region.srcSubresource.baseArrayLayer = 0;
2973 copy_region.dstSubresource.baseArrayLayer = 0;
2974 copy_region.srcSubresource.layerCount = 1;
2975 copy_region.dstSubresource.layerCount = 1;
2976 copy_region.srcOffset = {0, 0, 0};
2977 copy_region.dstOffset = {0, 0, 0};
2978
2979 // Sanity check
unknown088160a2019-05-23 17:43:13 -06002980 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
unknown088160a2019-05-23 17:43:13 -06002981
2982 std::string vuid;
2983 bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
2984 (DeviceValidationVersion() >= VK_API_VERSION_1_1));
2985
2986 // Src, Dest offsets must be multiples of compressed block sizes {4, 4, 1}
2987 // Image transfer granularity gets set to compressed block size, so an ITG error is also (unavoidably) triggered.
Shannon McPherson2c793ba2020-08-28 12:13:24 -06002988 vuid = ycbcr ? "VUID-vkCmdCopyImage-srcImage-01727" : "VUID-vkCmdCopyImage-srcImage-01727";
unknown088160a2019-05-23 17:43:13 -06002989 copy_region.srcOffset = {2, 4, 0}; // source width
Mark Lobodzinski20310782020-02-28 14:25:17 -07002990 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2991 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002992 "VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity
2993 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
2994 m_errorMonitor->VerifyFound();
2995 copy_region.srcOffset = {12, 1, 0}; // source height
Mark Lobodzinski20310782020-02-28 14:25:17 -07002996 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2997 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002998 "VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity
2999 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3000 m_errorMonitor->VerifyFound();
3001 copy_region.srcOffset = {0, 0, 0};
3002
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003003 vuid = ycbcr ? "VUID-vkCmdCopyImage-dstImage-01731" : "VUID-vkCmdCopyImage-dstImage-01731";
unknown088160a2019-05-23 17:43:13 -06003004 copy_region.dstOffset = {1, 0, 0}; // dest width
Mark Lobodzinski20310782020-02-28 14:25:17 -07003005 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3006 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003007 "VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity
3008 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3009 m_errorMonitor->VerifyFound();
3010 copy_region.dstOffset = {4, 1, 0}; // dest height
Mark Lobodzinski20310782020-02-28 14:25:17 -07003011 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3012 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003013 "VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity
3014 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3015 m_errorMonitor->VerifyFound();
3016 copy_region.dstOffset = {0, 0, 0};
3017
3018 // Copy extent must be multiples of compressed block sizes {4, 4, 1} if not full width/height
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003019 vuid = ycbcr ? "VUID-vkCmdCopyImage-srcImage-01728" : "VUID-vkCmdCopyImage-srcImage-01728";
unknown088160a2019-05-23 17:43:13 -06003020 copy_region.extent = {62, 60, 1}; // source width
Mark Lobodzinski20310782020-02-28 14:25:17 -07003021 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3022 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003023 "VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity
3024 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3025 m_errorMonitor->VerifyFound();
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003026 vuid = ycbcr ? "VUID-vkCmdCopyImage-srcImage-01729" : "VUID-vkCmdCopyImage-srcImage-01729";
unknown088160a2019-05-23 17:43:13 -06003027 copy_region.extent = {60, 62, 1}; // source height
Mark Lobodzinski20310782020-02-28 14:25:17 -07003028 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3029 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003030 "VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity
3031 m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3032 m_errorMonitor->VerifyFound();
3033
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003034 vuid = ycbcr ? "VUID-vkCmdCopyImage-dstImage-01732" : "VUID-vkCmdCopyImage-dstImage-01732";
unknown088160a2019-05-23 17:43:13 -06003035 copy_region.extent = {62, 60, 1}; // dest width
Mark Lobodzinski20310782020-02-28 14:25:17 -07003036 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3037 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003038 "VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity
3039 m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3040 m_errorMonitor->VerifyFound();
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003041 vuid = ycbcr ? "VUID-vkCmdCopyImage-dstImage-01733" : "VUID-vkCmdCopyImage-dstImage-01733";
unknown088160a2019-05-23 17:43:13 -06003042 copy_region.extent = {60, 62, 1}; // dest height
Mark Lobodzinski20310782020-02-28 14:25:17 -07003043 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3044 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003045 "VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity
3046 m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &copy_region);
3047 m_errorMonitor->VerifyFound();
3048
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003049 // Note: "VUID-vkCmdCopyImage-srcImage-01730", "VUID-vkCmdCopyImage-dstImage-01734", "VUID-vkCmdCopyImage-srcImage-01730",
3050 // "VUID-vkCmdCopyImage-dstImage-01734"
unknown088160a2019-05-23 17:43:13 -06003051 // There are currently no supported compressed formats with a block depth other than 1,
3052 // so impossible to create a 'not a multiple' condition for depth.
3053 m_commandBuffer->end();
3054}
3055
3056TEST_F(VkLayerTest, CopyImageSinglePlane422Alignment) {
3057 // Image copy tests on single-plane _422 formats with block alignment errors
3058
3059 // Enable KHR multiplane req'd extensions
3060 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
3061 VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
3062 if (mp_extensions) {
3063 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
3064 }
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07003065 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003066 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06003067 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3068 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3069 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3070 if (mp_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003071 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06003072 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3073 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3074 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3075 } else {
3076 printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix);
3077 return;
3078 }
3079 ASSERT_NO_FATAL_FAILURE(InitState());
3080
3081 // Select a _422 format and verify support
sfricke-samsung1c61f192021-12-31 01:53:03 -06003082 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003083 ci.flags = 0;
3084 ci.imageType = VK_IMAGE_TYPE_2D;
3085 ci.format = VK_FORMAT_G8B8G8R8_422_UNORM_KHR;
3086 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3087 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3088 ci.mipLevels = 1;
3089 ci.arrayLayers = 1;
3090 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3091 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3092 ci.queueFamilyIndexCount = 0;
3093 ci.pQueueFamilyIndices = NULL;
3094 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3095
3096 // Verify formats
3097 VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
3098 bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
3099 if (!supported) {
3100 printf("%s Single-plane _422 image format not supported. Skipping test.\n", kSkipPrefix);
3101 return; // Assume there's low ROI on searching for different mp formats
3102 }
3103
3104 // Create images
3105 ci.extent = {64, 64, 1};
3106 VkImageObj image_422(m_device);
3107 image_422.init(&ci);
3108 ASSERT_TRUE(image_422.initialized());
3109
3110 ci.extent = {64, 64, 1};
3111 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
3112 VkImageObj image_ucmp(m_device);
3113 image_ucmp.init(&ci);
3114 ASSERT_TRUE(image_ucmp.initialized());
3115
3116 m_commandBuffer->begin();
3117
3118 VkImageCopy copy_region;
3119 copy_region.extent = {48, 48, 1};
3120 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3121 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3122 copy_region.srcSubresource.mipLevel = 0;
3123 copy_region.dstSubresource.mipLevel = 0;
3124 copy_region.srcSubresource.baseArrayLayer = 0;
3125 copy_region.dstSubresource.baseArrayLayer = 0;
3126 copy_region.srcSubresource.layerCount = 1;
3127 copy_region.dstSubresource.layerCount = 1;
3128 copy_region.srcOffset = {0, 0, 0};
3129 copy_region.dstOffset = {0, 0, 0};
3130
3131 // Src offsets must be multiples of compressed block sizes
3132 copy_region.srcOffset = {3, 4, 0}; // source offset x
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003133 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01727");
Mark Lobodzinski20310782020-02-28 14:25:17 -07003134 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783");
unknown088160a2019-05-23 17:43:13 -06003135 m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3136 &copy_region);
3137 m_errorMonitor->VerifyFound();
3138 copy_region.srcOffset = {0, 0, 0};
3139
3140 // Dst offsets must be multiples of compressed block sizes
3141 copy_region.dstOffset = {1, 0, 0};
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003142 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01731");
Mark Lobodzinski20310782020-02-28 14:25:17 -07003143 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-01784");
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003144 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00150");
unknown088160a2019-05-23 17:43:13 -06003145 m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3146 &copy_region);
3147 m_errorMonitor->VerifyFound();
3148 copy_region.dstOffset = {0, 0, 0};
3149
3150 // Copy extent must be multiples of compressed block sizes if not full width/height
3151 copy_region.extent = {31, 60, 1}; // 422 source, extent.x
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003152 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01728");
Mark Lobodzinski20310782020-02-28 14:25:17 -07003153 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783");
unknown088160a2019-05-23 17:43:13 -06003154 m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3155 &copy_region);
3156 m_errorMonitor->VerifyFound();
3157
unknown357e1782019-09-25 17:57:40 -06003158 // 422 dest
unknown088160a2019-05-23 17:43:13 -06003159 m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3160 &copy_region);
unknown088160a2019-05-23 17:43:13 -06003161 copy_region.dstOffset = {0, 0, 0};
3162
3163 m_commandBuffer->end();
3164}
3165
3166TEST_F(VkLayerTest, CopyImageMultiplaneAspectBits) {
3167 // Image copy tests on multiplane images with aspect errors
3168
3169 // Enable KHR multiplane req'd extensions
3170 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
3171 VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
3172 if (mp_extensions) {
3173 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
3174 }
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07003175 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003176 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06003177 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3178 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3179 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3180 if (mp_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003181 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06003182 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3183 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3184 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3185 } else {
3186 printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix);
3187 return;
3188 }
3189 ASSERT_NO_FATAL_FAILURE(InitState());
3190
3191 // Select multi-plane formats and verify support
3192 VkFormat mp3_format = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR;
3193 VkFormat mp2_format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR;
3194
sfricke-samsung1c61f192021-12-31 01:53:03 -06003195 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003196 ci.flags = 0;
3197 ci.imageType = VK_IMAGE_TYPE_2D;
3198 ci.format = mp2_format;
3199 ci.extent = {256, 256, 1};
3200 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3201 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3202 ci.mipLevels = 1;
3203 ci.arrayLayers = 1;
3204 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3205 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3206 ci.queueFamilyIndexCount = 0;
3207 ci.pQueueFamilyIndices = NULL;
3208 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3209
3210 // Verify formats
3211 VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
3212 bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
3213 ci.format = VK_FORMAT_D24_UNORM_S8_UINT;
3214 supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
3215 ci.format = mp3_format;
3216 supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
3217 if (!supported) {
3218 printf("%s Multiplane image formats or optimally tiled depth-stencil buffers not supported. Skipping test.\n",
3219 kSkipPrefix);
3220 return; // Assume there's low ROI on searching for different mp formats
3221 }
3222
3223 // Create images
3224 VkImageObj mp3_image(m_device);
3225 mp3_image.init(&ci);
3226 ASSERT_TRUE(mp3_image.initialized());
3227
3228 ci.format = mp2_format;
3229 VkImageObj mp2_image(m_device);
3230 mp2_image.init(&ci);
3231 ASSERT_TRUE(mp2_image.initialized());
3232
3233 ci.format = VK_FORMAT_D24_UNORM_S8_UINT;
3234 VkImageObj sp_image(m_device);
3235 sp_image.init(&ci);
3236 ASSERT_TRUE(sp_image.initialized());
3237
3238 m_commandBuffer->begin();
3239
3240 VkImageCopy copy_region;
3241 copy_region.extent = {128, 128, 1};
3242 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
3243 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
3244 copy_region.srcSubresource.mipLevel = 0;
3245 copy_region.dstSubresource.mipLevel = 0;
3246 copy_region.srcSubresource.baseArrayLayer = 0;
3247 copy_region.dstSubresource.baseArrayLayer = 0;
3248 copy_region.srcSubresource.layerCount = 1;
3249 copy_region.dstSubresource.layerCount = 1;
3250 copy_region.srcOffset = {0, 0, 0};
3251 copy_region.dstOffset = {0, 0, 0};
3252
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003253 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01552");
unknown088160a2019-05-23 17:43:13 -06003254 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3255 &copy_region);
3256 m_errorMonitor->VerifyFound();
3257
unknown088160a2019-05-23 17:43:13 -06003258 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3259 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003260 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01553");
unknown088160a2019-05-23 17:43:13 -06003261 m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3262 &copy_region);
3263 m_errorMonitor->VerifyFound();
3264
3265 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR;
3266 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003267 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01554");
unknown088160a2019-05-23 17:43:13 -06003268 m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3269 &copy_region);
3270 m_errorMonitor->VerifyFound();
3271
3272 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003273 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01555");
unknown088160a2019-05-23 17:43:13 -06003274 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3275 &copy_region);
3276 m_errorMonitor->VerifyFound();
3277
3278 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003279 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-01556");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003280 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable
unknown088160a2019-05-23 17:43:13 -06003281 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3282 &copy_region);
3283 m_errorMonitor->VerifyFound();
3284
3285 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
3286 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003287 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImage-01557");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003288 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable
unknown088160a2019-05-23 17:43:13 -06003289 m_commandBuffer->CopyImage(sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3290 &copy_region);
3291 m_errorMonitor->VerifyFound();
3292
3293 m_commandBuffer->end();
3294}
3295
3296TEST_F(VkLayerTest, CopyImageSrcSizeExceeded) {
3297 // Image copy with source region specified greater than src image size
3298 ASSERT_NO_FATAL_FAILURE(Init());
3299
3300 // Create images with full mip chain
sfricke-samsung1c61f192021-12-31 01:53:03 -06003301 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003302 ci.flags = 0;
3303 ci.imageType = VK_IMAGE_TYPE_3D;
3304 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
3305 ci.extent = {32, 32, 8};
3306 ci.mipLevels = 6;
3307 ci.arrayLayers = 1;
3308 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3309 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3310 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3311 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3312 ci.queueFamilyIndexCount = 0;
3313 ci.pQueueFamilyIndices = NULL;
3314 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3315
3316 VkImageObj src_image(m_device);
3317 src_image.init(&ci);
3318 ASSERT_TRUE(src_image.initialized());
3319
3320 // Dest image with one more mip level
3321 ci.extent = {64, 64, 16};
3322 ci.mipLevels = 7;
3323 ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3324 VkImageObj dst_image(m_device);
3325 dst_image.init(&ci);
3326 ASSERT_TRUE(dst_image.initialized());
3327
3328 m_commandBuffer->begin();
3329
3330 VkImageCopy copy_region;
3331 copy_region.extent = {32, 32, 8};
3332 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3333 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3334 copy_region.srcSubresource.mipLevel = 0;
3335 copy_region.dstSubresource.mipLevel = 0;
3336 copy_region.srcSubresource.baseArrayLayer = 0;
3337 copy_region.dstSubresource.baseArrayLayer = 0;
3338 copy_region.srcSubresource.layerCount = 1;
3339 copy_region.dstSubresource.layerCount = 1;
3340 copy_region.srcOffset = {0, 0, 0};
3341 copy_region.dstOffset = {0, 0, 0};
3342
unknown088160a2019-05-23 17:43:13 -06003343 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3344 &copy_region);
unknown088160a2019-05-23 17:43:13 -06003345
sfricke-samsung066e0c72022-03-15 23:35:23 -05003346 // Source exceeded in x-dim
unknown088160a2019-05-23 17:43:13 -06003347 copy_region.srcOffset.x = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003348 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00144");
unknown088160a2019-05-23 17:43:13 -06003349 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3350 &copy_region);
3351 m_errorMonitor->VerifyFound();
3352
sfricke-samsung066e0c72022-03-15 23:35:23 -05003353 // Dest exceeded in x-dim in negative direction (since offset is a signed in)
3354 copy_region.extent.width = 4;
3355 copy_region.srcOffset.x = -8;
3356 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00144");
3357 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3358 &copy_region);
3359 m_errorMonitor->VerifyFound();
3360 copy_region.extent.width = 32;
3361
3362 // Source exceeded in y-dim
unknown088160a2019-05-23 17:43:13 -06003363 copy_region.srcOffset.x = 0;
3364 copy_region.extent.height = 48;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003365 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00145");
unknown088160a2019-05-23 17:43:13 -06003366 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3367 &copy_region);
3368 m_errorMonitor->VerifyFound();
3369
sfricke-samsung066e0c72022-03-15 23:35:23 -05003370 // Source exceeded in z-dim
unknown088160a2019-05-23 17:43:13 -06003371 copy_region.extent = {4, 4, 4};
3372 copy_region.srcSubresource.mipLevel = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003373 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00147");
unknown088160a2019-05-23 17:43:13 -06003374 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3375 &copy_region);
3376 m_errorMonitor->VerifyFound();
3377
3378 m_commandBuffer->end();
3379}
3380
3381TEST_F(VkLayerTest, CopyImageDstSizeExceeded) {
3382 // Image copy with dest region specified greater than dest image size
3383 ASSERT_NO_FATAL_FAILURE(Init());
3384
3385 // Create images with full mip chain
sfricke-samsung1c61f192021-12-31 01:53:03 -06003386 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003387 ci.flags = 0;
3388 ci.imageType = VK_IMAGE_TYPE_3D;
3389 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
3390 ci.extent = {32, 32, 8};
3391 ci.mipLevels = 6;
3392 ci.arrayLayers = 1;
3393 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3394 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3395 ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3396 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3397 ci.queueFamilyIndexCount = 0;
3398 ci.pQueueFamilyIndices = NULL;
3399 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3400
3401 VkImageObj dst_image(m_device);
3402 dst_image.init(&ci);
3403 ASSERT_TRUE(dst_image.initialized());
3404
3405 // Src image with one more mip level
3406 ci.extent = {64, 64, 16};
3407 ci.mipLevels = 7;
3408 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3409 VkImageObj src_image(m_device);
3410 src_image.init(&ci);
3411 ASSERT_TRUE(src_image.initialized());
3412
3413 m_commandBuffer->begin();
3414
3415 VkImageCopy copy_region;
3416 copy_region.extent = {32, 32, 8};
3417 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3418 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3419 copy_region.srcSubresource.mipLevel = 0;
3420 copy_region.dstSubresource.mipLevel = 0;
3421 copy_region.srcSubresource.baseArrayLayer = 0;
3422 copy_region.dstSubresource.baseArrayLayer = 0;
3423 copy_region.srcSubresource.layerCount = 1;
3424 copy_region.dstSubresource.layerCount = 1;
3425 copy_region.srcOffset = {0, 0, 0};
3426 copy_region.dstOffset = {0, 0, 0};
3427
unknown088160a2019-05-23 17:43:13 -06003428 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3429 &copy_region);
unknown088160a2019-05-23 17:43:13 -06003430
sfricke-samsung066e0c72022-03-15 23:35:23 -05003431 // Dest exceeded in x-dim
unknown088160a2019-05-23 17:43:13 -06003432 copy_region.dstOffset.x = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003433 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00150");
unknown088160a2019-05-23 17:43:13 -06003434 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3435 &copy_region);
3436 m_errorMonitor->VerifyFound();
3437
sfricke-samsung066e0c72022-03-15 23:35:23 -05003438 // Dest exceeded in x-dim in negative direction (since offset is a signed in)
3439 copy_region.extent.width = 4;
3440 copy_region.dstOffset.x = -8;
3441 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00150");
3442 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3443 &copy_region);
3444 m_errorMonitor->VerifyFound();
3445 copy_region.extent.width = 32;
3446
unknown088160a2019-05-23 17:43:13 -06003447 copy_region.dstOffset.x = 0;
3448 copy_region.extent.height = 48;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003449 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00151");
unknown088160a2019-05-23 17:43:13 -06003450 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3451 &copy_region);
3452 m_errorMonitor->VerifyFound();
3453
sfricke-samsung066e0c72022-03-15 23:35:23 -05003454 // Dest exceeded in z-dim
unknown088160a2019-05-23 17:43:13 -06003455 copy_region.extent = {4, 4, 4};
3456 copy_region.dstSubresource.mipLevel = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003457 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00153");
unknown088160a2019-05-23 17:43:13 -06003458 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3459 &copy_region);
3460 m_errorMonitor->VerifyFound();
3461
3462 m_commandBuffer->end();
3463}
3464
sfricke-samsungea1154b2022-03-31 22:29:34 -05003465TEST_F(VkLayerTest, CopyImageZeroSize) {
3466 TEST_DESCRIPTION("Image Copy with empty regions");
3467 ASSERT_NO_FATAL_FAILURE(Init());
3468
3469 // Create images with full mip chain
3470 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
3471 ci.flags = 0;
3472 ci.imageType = VK_IMAGE_TYPE_3D;
3473 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
3474 ci.extent = {32, 32, 8};
3475 ci.mipLevels = 6;
3476 ci.arrayLayers = 1;
3477 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3478 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3479 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3480 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3481 ci.queueFamilyIndexCount = 0;
3482 ci.pQueueFamilyIndices = NULL;
3483 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3484
3485 VkImageObj src_image(m_device);
3486 src_image.init(&ci);
3487 ASSERT_TRUE(src_image.initialized());
3488
3489 ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3490 VkImageObj dst_image(m_device);
3491 dst_image.init(&ci);
3492 ASSERT_TRUE(dst_image.initialized());
3493
3494 VkBufferObj buffer;
3495 VkMemoryPropertyFlags reqs = 0;
3496 buffer.init_as_src_and_dst(*m_device, 16384, reqs); // large enough for image
3497
3498 m_commandBuffer->begin();
3499
3500 VkImageCopy copy_region;
3501 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3502 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3503 copy_region.srcSubresource.mipLevel = 0;
3504 copy_region.dstSubresource.mipLevel = 0;
3505 copy_region.srcSubresource.baseArrayLayer = 0;
3506 copy_region.dstSubresource.baseArrayLayer = 0;
3507 copy_region.srcSubresource.layerCount = 1;
3508 copy_region.dstSubresource.layerCount = 1;
3509 copy_region.srcOffset = {0, 0, 0};
3510 copy_region.dstOffset = {0, 0, 0};
3511
3512 copy_region.extent = {4, 4, 0};
3513 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-06670");
3514 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3515 &copy_region);
3516 m_errorMonitor->VerifyFound();
3517
3518 copy_region.extent = {0, 0, 4};
3519 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-06668"); // width
3520 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-06669"); // height
3521 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3522 &copy_region);
3523 m_errorMonitor->VerifyFound();
3524
3525 VkImageSubresourceLayers image_subresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
3526 VkBufferImageCopy buffer_image_copy;
3527 buffer_image_copy.bufferRowLength = 0;
3528 buffer_image_copy.bufferImageHeight = 0;
3529 buffer_image_copy.imageSubresource = image_subresource;
3530 buffer_image_copy.imageOffset = {0, 0, 0};
3531 buffer_image_copy.bufferOffset = 0;
3532
3533 buffer_image_copy.imageExtent = {4, 0, 1};
3534 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06660");
3535 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer.handle(), 1,
3536 &buffer_image_copy);
3537 m_errorMonitor->VerifyFound();
3538
3539 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06660");
3540 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
3541 &buffer_image_copy);
3542 m_errorMonitor->VerifyFound();
3543
3544 // depth is now zero
3545 buffer_image_copy.imageExtent = {4, 1, 0};
3546 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06661");
3547 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer.handle(), 1,
3548 &buffer_image_copy);
3549 m_errorMonitor->VerifyFound();
3550
3551 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageExtent-06661");
3552 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
3553 &buffer_image_copy);
3554 m_errorMonitor->VerifyFound();
3555
3556 m_commandBuffer->end();
3557}
3558
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003559TEST_F(VkLayerTest, CopyImageMultiPlaneSizeExceeded) {
3560 TEST_DESCRIPTION("Image Copy for multi-planar format that exceed size of plane for both src and dst");
3561
3562 // Enable KHR multiplane req'd extensions
3563 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
3564 VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
3565 if (mp_extensions == true) {
3566 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
3567 }
3568 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003569 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003570 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3571 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3572 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3573 if (mp_extensions == true) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07003574 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003575 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
3576 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
3577 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3578 } else {
3579 printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix);
3580 return;
3581 }
3582 ASSERT_NO_FATAL_FAILURE(InitState());
3583
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003584 // Try to use VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM because need multi-plane format for some tests and likely supported due to
3585 // copy support being required with samplerYcbcrConversion feature
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003586 VkFormatProperties props = {0, 0, 0};
3587 bool missing_format_support = false;
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003588 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, &props);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003589 missing_format_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
3590 missing_format_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
3591 missing_format_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
3592
3593 if (missing_format_support == true) {
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003594 printf("%s VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM transfer not supported; skipped.\n", kSkipPrefix);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003595 return;
3596 }
3597
3598 // 128^2 texels in plane_0 and 64^2 texels in plane_1
3599 VkImageObj src_image(m_device);
3600 VkImageObj dst_image(m_device);
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003601 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 -08003602 ASSERT_TRUE(src_image.initialized());
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003603 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 -08003604 ASSERT_TRUE(dst_image.initialized());
3605
3606 VkImageCopy copy_region = {};
3607 copy_region.extent = {64, 64, 1}; // Size of plane 1
3608 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3609 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3610 copy_region.srcSubresource.mipLevel = 0;
3611 copy_region.dstSubresource.mipLevel = 0;
3612 copy_region.srcSubresource.baseArrayLayer = 0;
3613 copy_region.dstSubresource.baseArrayLayer = 0;
3614 copy_region.srcSubresource.layerCount = 1;
3615 copy_region.dstSubresource.layerCount = 1;
3616 copy_region.srcOffset = {0, 0, 0};
3617 copy_region.dstOffset = {0, 0, 0};
3618 VkImageCopy original_region = copy_region;
3619
3620 m_commandBuffer->begin();
3621
3622 // Should be able to do a 64x64 copy from plane 1 -> Plane 1
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003623 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3624 &copy_region);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003625
3626 // Should be able to do a 64x64 copy from plane 0 -> Plane 0
3627 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
3628 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003629 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3630 &copy_region);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003631
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07003632 VkMemoryBarrier mem_barrier = LvlInitStruct<VkMemoryBarrier>();
locke-lunargdf00db02020-03-04 19:00:57 -07003633 mem_barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
3634 mem_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
3635
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003636 // Should be able to do a 64x64 copy from plane 0 -> Plane 1
3637 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
3638 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
locke-lunargdf00db02020-03-04 19:00:57 -07003639 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
3640 &mem_barrier, 0, nullptr, 0, nullptr);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003641 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3642 &copy_region);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003643
3644 // Should be able to do a 64x64 copy from plane 0 -> Plane 1
3645 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3646 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
locke-lunargdf00db02020-03-04 19:00:57 -07003647 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
3648 &mem_barrier, 0, nullptr, 0, nullptr);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003649 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3650 &copy_region);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003651
3652 // Should be able to do a 128x64 copy from plane 0 -> Plane 0
3653 copy_region.extent = {128, 64, 1};
3654 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
3655 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
locke-lunargdf00db02020-03-04 19:00:57 -07003656 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1,
3657 &mem_barrier, 0, nullptr, 0, nullptr);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003658 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3659 &copy_region);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003660
3661 // 128x64 copy from plane 0 -> Plane 1
3662 copy_region.extent = {128, 64, 1};
3663 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
3664 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003665 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00150");
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003666 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3667 &copy_region);
3668 m_errorMonitor->VerifyFound();
3669
3670 // 128x64 copy from plane 1 -> Plane 0
3671 copy_region.extent = {128, 64, 1};
3672 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3673 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003674 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00144");
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003675 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3676 &copy_region);
3677 m_errorMonitor->VerifyFound();
3678
3679 // src exceeded in y-dim from offset
3680 copy_region = original_region;
3681 copy_region.srcOffset.y = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003682 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-00145");
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003683 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3684 &copy_region);
3685 m_errorMonitor->VerifyFound();
3686
3687 // dst exceeded in y-dim from offset
3688 copy_region = original_region;
3689 copy_region.dstOffset.y = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06003690 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-00151");
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003691 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3692 &copy_region);
3693 m_errorMonitor->VerifyFound();
3694
3695 m_commandBuffer->end();
3696}
3697
unknown088160a2019-05-23 17:43:13 -06003698TEST_F(VkLayerTest, CopyImageFormatSizeMismatch) {
sjfricke3a10ae82022-08-02 18:48:57 +09003699 if (!OverrideDevsimForDeviceProfileLayer()) {
3700 GTEST_SKIP() << "Failed to override devsim for device profile layer.";
sfricke-samsung51067b22020-04-30 21:41:17 -07003701 }
unknown088160a2019-05-23 17:43:13 -06003702
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003703 // Enable KHR multiplane req'd extensions
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06003704 AddRequiredExtensions(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
3705 ASSERT_NO_FATAL_FAILURE(InitFramework());
3706 if (!AreRequiredExtensionsEnabled()) {
3707 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003708 }
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06003709 auto mp_features = LvlInitStruct<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>();
3710 auto features2 = GetPhysicalDeviceFeatures2(mp_features);
3711
3712 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
unknown088160a2019-05-23 17:43:13 -06003713
sfricke-samsung51067b22020-04-30 21:41:17 -07003714 PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr;
3715 PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr;
sfricke-samsung51067b22020-04-30 21:41:17 -07003716 if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) {
sjfricke3a10ae82022-08-02 18:48:57 +09003717 GTEST_SKIP() << "Failed to load device profile layer.";
sfricke-samsung51067b22020-04-30 21:41:17 -07003718 }
3719
3720 // Set transfer for all potential used formats
3721 VkFormatProperties format_props;
3722 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UNORM, &format_props);
3723 format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
3724 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UNORM, format_props);
3725
3726 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UINT, &format_props);
3727 format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
3728 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UINT, format_props);
unknown088160a2019-05-23 17:43:13 -06003729
sfricke-samsung1c61f192021-12-31 01:53:03 -06003730 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003731 image_create_info.imageType = VK_IMAGE_TYPE_2D;
unknown088160a2019-05-23 17:43:13 -06003732 image_create_info.extent.width = 32;
3733 image_create_info.extent.height = 32;
3734 image_create_info.extent.depth = 1;
3735 image_create_info.mipLevels = 1;
3736 image_create_info.arrayLayers = 1;
3737 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
sfricke-samsung51067b22020-04-30 21:41:17 -07003738 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
3739 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
unknown088160a2019-05-23 17:43:13 -06003740 image_create_info.flags = 0;
3741
sfricke-samsung51067b22020-04-30 21:41:17 -07003742 image_create_info.format = VK_FORMAT_R8_UNORM;
3743 VkImageObj image_8b_unorm(m_device);
3744 image_8b_unorm.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003745
sfricke-samsung51067b22020-04-30 21:41:17 -07003746 image_create_info.format = VK_FORMAT_R8_UINT;
3747 VkImageObj image_8b_uint(m_device);
3748 image_8b_uint.init(&image_create_info);
3749
3750 // First try to test two single plane mismatch
3751 {
3752 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8G8B8A8_UNORM, &format_props);
3753 format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
3754 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8G8B8A8_UNORM, format_props);
3755
3756 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
3757 VkImageObj image_32b_unorm(m_device);
3758 image_32b_unorm.init(&image_create_info);
3759
3760 m_commandBuffer->begin();
3761 VkImageCopy copyRegion;
3762 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3763 copyRegion.srcSubresource.mipLevel = 0;
3764 copyRegion.srcSubresource.baseArrayLayer = 0;
3765 copyRegion.srcSubresource.layerCount = 1;
3766 copyRegion.srcOffset.x = 0;
3767 copyRegion.srcOffset.y = 0;
3768 copyRegion.srcOffset.z = 0;
3769 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3770 copyRegion.dstSubresource.mipLevel = 0;
3771 copyRegion.dstSubresource.baseArrayLayer = 0;
3772 copyRegion.dstSubresource.layerCount = 1;
3773 copyRegion.dstOffset.x = 0;
3774 copyRegion.dstOffset.y = 0;
3775 copyRegion.dstOffset.z = 0;
3776 copyRegion.extent.width = 1;
3777 copyRegion.extent.height = 1;
3778 copyRegion.extent.depth = 1;
3779
3780 // Sanity check between two 8bit formats
sfricke-samsung51067b22020-04-30 21:41:17 -07003781 m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_uint.handle(),
3782 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
sfricke-samsung51067b22020-04-30 21:41:17 -07003783
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06003784 const char *vuid = (IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME))
3785 ? "VUID-vkCmdCopyImage-srcImage-01548"
3786 : "VUID-vkCmdCopyImage-srcImage-00135";
sfricke-samsung51067b22020-04-30 21:41:17 -07003787 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3788 m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_32b_unorm.handle(),
3789 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
3790 m_errorMonitor->VerifyFound();
3791
3792 // Swap src and dst
3793 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
3794 m_commandBuffer->CopyImage(image_32b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(),
3795 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
3796 m_errorMonitor->VerifyFound();
3797
3798 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06003799 }
3800
sfricke-samsung51067b22020-04-30 21:41:17 -07003801 // DstImage is a mismatched plane of a multi-planar format
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06003802 if (!mp_features.samplerYcbcrConversion) {
sfricke-samsung51067b22020-04-30 21:41:17 -07003803 printf("%s No multi-planar support; section of tests skipped.\n", kSkipPrefix);
3804 } else {
3805 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &format_props);
3806 format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
3807 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, format_props);
unknown088160a2019-05-23 17:43:13 -06003808
sfricke-samsung51067b22020-04-30 21:41:17 -07003809 image_create_info.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
3810 VkImageObj image_8b_16b_420_unorm(m_device);
3811 image_8b_16b_420_unorm.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003812
sfricke-samsung51067b22020-04-30 21:41:17 -07003813 m_commandBuffer->begin();
3814 VkImageCopy copyRegion;
3815 copyRegion.srcSubresource.mipLevel = 0;
3816 copyRegion.srcSubresource.baseArrayLayer = 0;
3817 copyRegion.srcSubresource.layerCount = 1;
3818 copyRegion.srcOffset.x = 0;
3819 copyRegion.srcOffset.y = 0;
3820 copyRegion.srcOffset.z = 0;
3821 copyRegion.dstSubresource.mipLevel = 0;
3822 copyRegion.dstSubresource.baseArrayLayer = 0;
3823 copyRegion.dstSubresource.layerCount = 1;
3824 copyRegion.dstOffset.x = 0;
3825 copyRegion.dstOffset.y = 0;
3826 copyRegion.dstOffset.z = 0;
3827 copyRegion.extent.width = 1;
3828 copyRegion.extent.height = 1;
3829 copyRegion.extent.depth = 1;
unknown088160a2019-05-23 17:43:13 -06003830
sfricke-samsung51067b22020-04-30 21:41:17 -07003831 // First test single-plane -> multi-plan
3832 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3833 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
unknown088160a2019-05-23 17:43:13 -06003834
sfricke-samsung51067b22020-04-30 21:41:17 -07003835 // Plane 0 is VK_FORMAT_R8_UNORM so this should succeed
sfricke-samsung51067b22020-04-30 21:41:17 -07003836 m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(),
3837 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003838
locke-lunargdf00db02020-03-04 19:00:57 -07003839 image_8b_16b_420_unorm.ImageMemoryBarrier(m_commandBuffer, VK_IMAGE_ASPECT_PLANE_0_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
3840 VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
3841
sfricke-samsung51067b22020-04-30 21:41:17 -07003842 // Make sure no false postiives if Compatible format
sfricke-samsung51067b22020-04-30 21:41:17 -07003843 m_commandBuffer->CopyImage(image_8b_uint.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(),
3844 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003845
sfricke-samsung51067b22020-04-30 21:41:17 -07003846 // Plane 1 is VK_FORMAT_R8G8_UNORM so this should fail
3847 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3848 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549");
3849 m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(),
3850 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
3851 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06003852
sfricke-samsung51067b22020-04-30 21:41:17 -07003853 // Same tests but swap src and dst
3854 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
3855 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
sfricke-samsungdce5f692020-03-07 13:59:31 -08003856
locke-lunargdf00db02020-03-04 19:00:57 -07003857 image_8b_unorm.ImageMemoryBarrier(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_ACCESS_TRANSFER_READ_BIT,
3858 VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
3859 image_8b_16b_420_unorm.ImageMemoryBarrier(m_commandBuffer, VK_IMAGE_ASPECT_PLANE_0_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
3860 VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL);
3861
sfricke-samsung51067b22020-04-30 21:41:17 -07003862 m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(),
3863 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
sfricke-samsung51067b22020-04-30 21:41:17 -07003864
locke-lunargdf00db02020-03-04 19:00:57 -07003865 image_8b_16b_420_unorm.ImageMemoryBarrier(m_commandBuffer, VK_IMAGE_ASPECT_PLANE_0_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
3866 VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL);
3867
sfricke-samsung51067b22020-04-30 21:41:17 -07003868 m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_uint.handle(),
3869 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
sfricke-samsung51067b22020-04-30 21:41:17 -07003870
3871 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
3872 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549");
3873 m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(),
3874 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
3875 m_errorMonitor->VerifyFound();
3876
3877 m_commandBuffer->end();
3878 }
unknown088160a2019-05-23 17:43:13 -06003879}
3880
3881TEST_F(VkLayerTest, CopyImageDepthStencilFormatMismatch) {
3882 ASSERT_NO_FATAL_FAILURE(Init());
3883 auto depth_format = FindSupportedDepthStencilFormat(gpu());
3884 if (!depth_format) {
3885 printf("%s Couldn't depth stencil image format.\n", kSkipPrefix);
3886 return;
3887 }
3888
3889 VkFormatProperties properties;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003890 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
unknown088160a2019-05-23 17:43:13 -06003891 if (properties.optimalTilingFeatures == 0) {
3892 printf("%s Image format not supported; skipped.\n", kSkipPrefix);
3893 return;
3894 }
3895
3896 VkImageObj srcImage(m_device);
3897 srcImage.Init(32, 32, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL);
3898 ASSERT_TRUE(srcImage.initialized());
3899 VkImageObj dstImage(m_device);
3900 dstImage.Init(32, 32, 1, depth_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL);
3901 ASSERT_TRUE(dstImage.initialized());
3902
3903 // Create two images of different types and try to copy between them
3904
3905 m_commandBuffer->begin();
3906 VkImageCopy copyRegion;
3907 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
3908 copyRegion.srcSubresource.mipLevel = 0;
3909 copyRegion.srcSubresource.baseArrayLayer = 0;
3910 copyRegion.srcSubresource.layerCount = 1;
3911 copyRegion.srcOffset.x = 0;
3912 copyRegion.srcOffset.y = 0;
3913 copyRegion.srcOffset.z = 0;
3914 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
3915 copyRegion.dstSubresource.mipLevel = 0;
3916 copyRegion.dstSubresource.baseArrayLayer = 0;
3917 copyRegion.dstSubresource.layerCount = 1;
3918 copyRegion.dstOffset.x = 0;
3919 copyRegion.dstOffset.y = 0;
3920 copyRegion.dstOffset.z = 0;
3921 copyRegion.extent.width = 1;
3922 copyRegion.extent.height = 1;
3923 copyRegion.extent.depth = 1;
3924
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003925 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00135");
unknown088160a2019-05-23 17:43:13 -06003926 m_commandBuffer->CopyImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
3927 &copyRegion);
3928 m_commandBuffer->end();
3929
3930 m_errorMonitor->VerifyFound();
3931}
3932
3933TEST_F(VkLayerTest, CopyImageSampleCountMismatch) {
3934 TEST_DESCRIPTION("Image copies with sample count mis-matches");
3935
3936 ASSERT_NO_FATAL_FAILURE(Init());
3937
3938 VkImageFormatProperties image_format_properties;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003939 vk::GetPhysicalDeviceImageFormatProperties(gpu(), VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
3940 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
3941 &image_format_properties);
unknown088160a2019-05-23 17:43:13 -06003942
3943 if ((0 == (VK_SAMPLE_COUNT_2_BIT & image_format_properties.sampleCounts)) ||
3944 (0 == (VK_SAMPLE_COUNT_4_BIT & image_format_properties.sampleCounts))) {
3945 printf("%s Image multi-sample support not found; skipped.\n", kSkipPrefix);
3946 return;
3947 }
3948
sfricke-samsung1c61f192021-12-31 01:53:03 -06003949 VkImageCreateInfo ci = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06003950 ci.flags = 0;
3951 ci.imageType = VK_IMAGE_TYPE_2D;
3952 ci.format = VK_FORMAT_R8G8B8A8_UNORM;
3953 ci.extent = {128, 128, 1};
3954 ci.mipLevels = 1;
3955 ci.arrayLayers = 1;
3956 ci.samples = VK_SAMPLE_COUNT_1_BIT;
3957 ci.tiling = VK_IMAGE_TILING_OPTIMAL;
3958 ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3959 ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
3960 ci.queueFamilyIndexCount = 0;
3961 ci.pQueueFamilyIndices = NULL;
3962 ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
3963
3964 VkImageObj image1(m_device);
3965 image1.init(&ci);
3966 ASSERT_TRUE(image1.initialized());
3967
3968 ci.samples = VK_SAMPLE_COUNT_2_BIT;
3969 VkImageObj image2(m_device);
3970 image2.init(&ci);
3971 ASSERT_TRUE(image2.initialized());
3972
3973 ci.samples = VK_SAMPLE_COUNT_4_BIT;
3974 VkImageObj image4(m_device);
3975 image4.init(&ci);
3976 ASSERT_TRUE(image4.initialized());
3977
3978 m_commandBuffer->begin();
3979
3980 VkImageCopy copyRegion;
3981 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3982 copyRegion.srcSubresource.mipLevel = 0;
3983 copyRegion.srcSubresource.baseArrayLayer = 0;
3984 copyRegion.srcSubresource.layerCount = 1;
3985 copyRegion.srcOffset = {0, 0, 0};
3986 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
3987 copyRegion.dstSubresource.mipLevel = 0;
3988 copyRegion.dstSubresource.baseArrayLayer = 0;
3989 copyRegion.dstSubresource.layerCount = 1;
3990 copyRegion.dstOffset = {0, 0, 0};
3991 copyRegion.extent = {128, 128, 1};
3992
3993 // Copy a single sample image to/from a multi-sample image
Mark Lobodzinski20310782020-02-28 14:25:17 -07003994 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003995 vk::CmdCopyImage(m_commandBuffer->handle(), image1.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL,
3996 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003997 m_errorMonitor->VerifyFound();
3998
Mark Lobodzinski20310782020-02-28 14:25:17 -07003999 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004000 vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image1.handle(), VK_IMAGE_LAYOUT_GENERAL,
4001 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004002 m_errorMonitor->VerifyFound();
4003
4004 // Copy between multi-sample images with different sample counts
Mark Lobodzinski20310782020-02-28 14:25:17 -07004005 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004006 vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL,
4007 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004008 m_errorMonitor->VerifyFound();
4009
Mark Lobodzinski20310782020-02-28 14:25:17 -07004010 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004011 vk::CmdCopyImage(m_commandBuffer->handle(), image4.handle(), VK_IMAGE_LAYOUT_GENERAL, image2.handle(), VK_IMAGE_LAYOUT_GENERAL,
4012 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004013 m_errorMonitor->VerifyFound();
4014
4015 m_commandBuffer->end();
4016}
4017
4018TEST_F(VkLayerTest, CopyImageAspectMismatch) {
4019 TEST_DESCRIPTION("Image copies with aspect mask errors");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004020
sjfricke3a10ae82022-08-02 18:48:57 +09004021 if (!OverrideDevsimForDeviceProfileLayer()) {
4022 GTEST_SKIP() << "Failed to override devsim for device profile layer.";
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004023 }
4024
4025 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1);
4026 if (mp_extensions) {
4027 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
4028 }
4029
4030 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07004031 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004032 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
4033 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
4034 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
4035 if (mp_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07004036 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004037 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
4038 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
4039 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
4040 }
4041 ASSERT_NO_FATAL_FAILURE(InitState());
4042
4043 PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr;
4044 PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr;
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004045 if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) {
sjfricke3a10ae82022-08-02 18:48:57 +09004046 GTEST_SKIP() << "Failed to load device profile layer.";
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004047 }
4048
unknown088160a2019-05-23 17:43:13 -06004049 auto ds_format = FindSupportedDepthStencilFormat(gpu());
4050 if (!ds_format) {
4051 printf("%s Couldn't find depth stencil format.\n", kSkipPrefix);
4052 return;
4053 }
4054
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004055 // Add Transfer support for all used formats
4056 VkFormatProperties formatProps;
4057 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, &formatProps);
4058 formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4059 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, formatProps);
4060 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D32_SFLOAT, &formatProps);
4061 formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4062 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, formatProps);
4063 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), ds_format, &formatProps);
4064 formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4065 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), ds_format, formatProps);
4066
unknown088160a2019-05-23 17:43:13 -06004067 VkImageObj color_image(m_device), ds_image(m_device), depth_image(m_device);
4068 color_image.Init(128, 128, 1, VK_FORMAT_R32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
4069 depth_image.Init(128, 128, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
4070 VK_IMAGE_TILING_OPTIMAL, 0);
4071 ds_image.Init(128, 128, 1, ds_format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
4072 VK_IMAGE_TILING_OPTIMAL, 0);
4073 ASSERT_TRUE(color_image.initialized());
4074 ASSERT_TRUE(depth_image.initialized());
4075 ASSERT_TRUE(ds_image.initialized());
4076
4077 VkImageCopy copyRegion;
4078 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
4079 copyRegion.srcSubresource.mipLevel = 0;
4080 copyRegion.srcSubresource.baseArrayLayer = 0;
4081 copyRegion.srcSubresource.layerCount = 1;
4082 copyRegion.srcOffset = {0, 0, 0};
4083 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
4084 copyRegion.dstSubresource.mipLevel = 0;
4085 copyRegion.dstSubresource.baseArrayLayer = 0;
4086 copyRegion.dstSubresource.layerCount = 1;
4087 copyRegion.dstOffset = {64, 0, 0};
4088 copyRegion.extent = {64, 128, 1};
4089
4090 // Submitting command before command buffer is in recording state
Mark Lobodzinski20310782020-02-28 14:25:17 -07004091 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06004092 "You must call vkBeginCommandBuffer"); // "VUID-vkCmdCopyImage-commandBuffer-recording");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004093 vk::CmdCopyImage(m_commandBuffer->handle(), depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
4094 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004095 m_errorMonitor->VerifyFound();
4096
4097 m_commandBuffer->begin();
4098
4099 // Src and dest aspect masks don't match
4100 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004101 const char *vuid = mp_extensions ? "VUID-vkCmdCopyImage-srcImage-01551" : "VUID-VkImageCopy-aspectMask-00137";
Mark Lobodzinski20310782020-02-28 14:25:17 -07004102 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004103 vk::CmdCopyImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, ds_image.handle(),
4104 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004105 m_errorMonitor->VerifyFound();
4106 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
4107
4108 // Illegal combinations of aspect bits
4109 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone
4110 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004111 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167");
unknown088160a2019-05-23 17:43:13 -06004112 // These aspect/format mismatches are redundant but unavoidable here
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004113 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspectMask-00142");
Mark Lobodzinski20310782020-02-28 14:25:17 -07004114 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004115 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
4116 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004117 m_errorMonitor->VerifyFound();
4118 // same test for dstSubresource
4119 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4120 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone
Mark Lobodzinski20310782020-02-28 14:25:17 -07004121 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167");
unknown088160a2019-05-23 17:43:13 -06004122 // These aspect/format mismatches are redundant but unavoidable here
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004123 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspectMask-00143");
Mark Lobodzinski20310782020-02-28 14:25:17 -07004124 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004125 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
4126 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004127 m_errorMonitor->VerifyFound();
4128
4129 // Metadata aspect is illegal
4130 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
4131 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004132 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168");
unknown088160a2019-05-23 17:43:13 -06004133 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07004134 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004135 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
4136 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004137 m_errorMonitor->VerifyFound();
4138 // same test for dstSubresource
4139 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4140 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004141 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168");
unknown088160a2019-05-23 17:43:13 -06004142 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07004143 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004144 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
4145 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004146 m_errorMonitor->VerifyFound();
4147
sfricke-samsung6141db32020-10-26 03:31:38 -07004148 // Aspect Memory Plane mask is illegal
4149 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT;
4150 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4151 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-02247");
4152 // These aspect/format mismatches are redundant but unavoidable here
4153 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
4154 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
4155 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
4156 m_errorMonitor->VerifyFound();
4157
unknown088160a2019-05-23 17:43:13 -06004158 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
4159 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004160 const char *compatible_vuid = mp_extensions ? "VUID-vkCmdCopyImage-srcImage-01548" : "VUID-vkCmdCopyImage-srcImage-00135";
unknown088160a2019-05-23 17:43:13 -06004161
4162 // Aspect mask doesn't match source image format
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004163 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspectMask-00142");
unknown088160a2019-05-23 17:43:13 -06004164 // Again redundant but unavoidable
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004165 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004166 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
4167 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004168 m_errorMonitor->VerifyFound();
4169
4170 // Aspect mask doesn't match dest image format
4171 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4172 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004173 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspectMask-00143");
unknown088160a2019-05-23 17:43:13 -06004174 // Again redundant but unavoidable
sfricke-samsung99dc12c2020-04-23 01:52:01 -07004175 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004176 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
4177 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06004178 m_errorMonitor->VerifyFound();
4179
aitor-lunarg54c295b2022-01-28 17:02:32 +01004180 // Check no performance warnings regarding layout are thrown when copying from and to the same image
4181 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
4182 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
aitor-lunarg54c295b2022-01-28 17:02:32 +01004183 vk::CmdCopyImage(m_commandBuffer->handle(), depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
4184 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
aitor-lunarg54c295b2022-01-28 17:02:32 +01004185
unknown088160a2019-05-23 17:43:13 -06004186 m_commandBuffer->end();
4187}
4188
4189TEST_F(VkLayerTest, ResolveImageLowSampleCount) {
sfricke-samsungc26350e2020-05-30 12:31:31 -07004190 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-00257");
unknown088160a2019-05-23 17:43:13 -06004191
4192 ASSERT_NO_FATAL_FAILURE(Init());
4193
4194 // Create two images of sample count 1 and try to Resolve between them
4195
sfricke-samsung1c61f192021-12-31 01:53:03 -06004196 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004197 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4198 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4199 image_create_info.extent.width = 32;
4200 image_create_info.extent.height = 1;
4201 image_create_info.extent.depth = 1;
4202 image_create_info.mipLevels = 1;
4203 image_create_info.arrayLayers = 1;
4204 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4205 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4206 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4207 image_create_info.flags = 0;
4208
4209 VkImageObj srcImage(m_device);
4210 srcImage.init(&image_create_info);
4211 ASSERT_TRUE(srcImage.initialized());
4212
4213 VkImageObj dstImage(m_device);
4214 dstImage.init(&image_create_info);
4215 ASSERT_TRUE(dstImage.initialized());
4216
4217 m_commandBuffer->begin();
4218 VkImageResolve resolveRegion;
4219 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4220 resolveRegion.srcSubresource.mipLevel = 0;
4221 resolveRegion.srcSubresource.baseArrayLayer = 0;
4222 resolveRegion.srcSubresource.layerCount = 1;
4223 resolveRegion.srcOffset.x = 0;
4224 resolveRegion.srcOffset.y = 0;
4225 resolveRegion.srcOffset.z = 0;
4226 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4227 resolveRegion.dstSubresource.mipLevel = 0;
4228 resolveRegion.dstSubresource.baseArrayLayer = 0;
4229 resolveRegion.dstSubresource.layerCount = 1;
4230 resolveRegion.dstOffset.x = 0;
4231 resolveRegion.dstOffset.y = 0;
4232 resolveRegion.dstOffset.z = 0;
4233 resolveRegion.extent.width = 1;
4234 resolveRegion.extent.height = 1;
4235 resolveRegion.extent.depth = 1;
4236 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
4237 &resolveRegion);
4238 m_commandBuffer->end();
4239
4240 m_errorMonitor->VerifyFound();
4241}
4242
4243TEST_F(VkLayerTest, ResolveImageHighSampleCount) {
sfricke-samsungc26350e2020-05-30 12:31:31 -07004244 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-00259");
unknown088160a2019-05-23 17:43:13 -06004245
4246 ASSERT_NO_FATAL_FAILURE(Init());
4247
4248 // Create two images of sample count 4 and try to Resolve between them
4249
sfricke-samsung1c61f192021-12-31 01:53:03 -06004250 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004251 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4252 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4253 image_create_info.extent.width = 32;
4254 image_create_info.extent.height = 1;
4255 image_create_info.extent.depth = 1;
4256 image_create_info.mipLevels = 1;
4257 image_create_info.arrayLayers = 1;
4258 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT;
4259 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4260 // Note: Some implementations expect color attachment usage for any
4261 // multisample surface
4262 image_create_info.usage =
4263 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4264 image_create_info.flags = 0;
4265
4266 VkImageObj srcImage(m_device);
4267 srcImage.init(&image_create_info);
4268 ASSERT_TRUE(srcImage.initialized());
4269
4270 VkImageObj dstImage(m_device);
4271 dstImage.init(&image_create_info);
4272 ASSERT_TRUE(dstImage.initialized());
4273
4274 m_commandBuffer->begin();
4275 // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
4276 // VK_IMAGE_LAYOUT_UNDEFINED = 0,
4277 // VK_IMAGE_LAYOUT_GENERAL = 1,
4278 VkImageResolve resolveRegion;
4279 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4280 resolveRegion.srcSubresource.mipLevel = 0;
4281 resolveRegion.srcSubresource.baseArrayLayer = 0;
4282 resolveRegion.srcSubresource.layerCount = 1;
4283 resolveRegion.srcOffset.x = 0;
4284 resolveRegion.srcOffset.y = 0;
4285 resolveRegion.srcOffset.z = 0;
4286 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4287 resolveRegion.dstSubresource.mipLevel = 0;
4288 resolveRegion.dstSubresource.baseArrayLayer = 0;
4289 resolveRegion.dstSubresource.layerCount = 1;
4290 resolveRegion.dstOffset.x = 0;
4291 resolveRegion.dstOffset.y = 0;
4292 resolveRegion.dstOffset.z = 0;
4293 resolveRegion.extent.width = 1;
4294 resolveRegion.extent.height = 1;
4295 resolveRegion.extent.depth = 1;
4296 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
4297 &resolveRegion);
4298 m_commandBuffer->end();
4299
4300 m_errorMonitor->VerifyFound();
4301}
4302
4303TEST_F(VkLayerTest, ResolveImageFormatMismatch) {
sfricke-samsungc26350e2020-05-30 12:31:31 -07004304 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-01386");
unknown088160a2019-05-23 17:43:13 -06004305
4306 ASSERT_NO_FATAL_FAILURE(Init());
4307
4308 // Create two images of different types and try to copy between them
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004309 VkImageObj srcImage(m_device);
4310 VkImageObj dstImage(m_device);
unknown088160a2019-05-23 17:43:13 -06004311
sfricke-samsung1c61f192021-12-31 01:53:03 -06004312 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004313 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4314 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4315 image_create_info.extent.width = 32;
4316 image_create_info.extent.height = 1;
4317 image_create_info.extent.depth = 1;
4318 image_create_info.mipLevels = 1;
4319 image_create_info.arrayLayers = 1;
sfricke-samsungf46582f2021-03-31 02:02:37 -07004320 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; // guarantee support from sampledImageColorSampleCounts
unknown088160a2019-05-23 17:43:13 -06004321 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4322 // Note: Some implementations expect color attachment usage for any
4323 // multisample surface
4324 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4325 image_create_info.flags = 0;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004326 srcImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06004327
4328 // Set format to something other than source image
4329 image_create_info.format = VK_FORMAT_R32_SFLOAT;
4330 // Note: Some implementations expect color attachment usage for any
4331 // multisample surface
4332 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4333 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004334 dstImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06004335
4336 m_commandBuffer->begin();
4337 // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
4338 // VK_IMAGE_LAYOUT_UNDEFINED = 0,
4339 // VK_IMAGE_LAYOUT_GENERAL = 1,
4340 VkImageResolve resolveRegion;
4341 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4342 resolveRegion.srcSubresource.mipLevel = 0;
4343 resolveRegion.srcSubresource.baseArrayLayer = 0;
4344 resolveRegion.srcSubresource.layerCount = 1;
4345 resolveRegion.srcOffset.x = 0;
4346 resolveRegion.srcOffset.y = 0;
4347 resolveRegion.srcOffset.z = 0;
4348 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4349 resolveRegion.dstSubresource.mipLevel = 0;
4350 resolveRegion.dstSubresource.baseArrayLayer = 0;
4351 resolveRegion.dstSubresource.layerCount = 1;
4352 resolveRegion.dstOffset.x = 0;
4353 resolveRegion.dstOffset.y = 0;
4354 resolveRegion.dstOffset.z = 0;
4355 resolveRegion.extent.width = 1;
4356 resolveRegion.extent.height = 1;
4357 resolveRegion.extent.depth = 1;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004358 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
4359 &resolveRegion);
unknown088160a2019-05-23 17:43:13 -06004360 m_commandBuffer->end();
4361
4362 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06004363}
4364
4365TEST_F(VkLayerTest, ResolveImageTypeMismatch) {
sfricke-samsungc26350e2020-05-30 12:31:31 -07004366 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "UNASSIGNED-CoreValidation-DrawState-MismatchedImageType");
unknown088160a2019-05-23 17:43:13 -06004367
4368 ASSERT_NO_FATAL_FAILURE(Init());
4369
4370 // Create two images of different types and try to copy between them
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004371 VkImageObj srcImage(m_device);
4372 VkImageObj dstImage(m_device);
unknown088160a2019-05-23 17:43:13 -06004373
sfricke-samsung1c61f192021-12-31 01:53:03 -06004374 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004375 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4376 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4377 image_create_info.extent.width = 32;
4378 image_create_info.extent.height = 1;
4379 image_create_info.extent.depth = 1;
4380 image_create_info.mipLevels = 1;
4381 image_create_info.arrayLayers = 1;
sfricke-samsungf46582f2021-03-31 02:02:37 -07004382 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; // guarantee support from sampledImageColorSampleCounts
unknown088160a2019-05-23 17:43:13 -06004383 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4384 // Note: Some implementations expect color attachment usage for any
4385 // multisample surface
4386 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4387 image_create_info.flags = 0;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004388 srcImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06004389
4390 image_create_info.imageType = VK_IMAGE_TYPE_1D;
4391 // Note: Some implementations expect color attachment usage for any
4392 // multisample surface
4393 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4394 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004395 dstImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06004396
4397 m_commandBuffer->begin();
4398 // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
4399 // VK_IMAGE_LAYOUT_UNDEFINED = 0,
4400 // VK_IMAGE_LAYOUT_GENERAL = 1,
4401 VkImageResolve resolveRegion;
4402 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4403 resolveRegion.srcSubresource.mipLevel = 0;
4404 resolveRegion.srcSubresource.baseArrayLayer = 0;
4405 resolveRegion.srcSubresource.layerCount = 1;
4406 resolveRegion.srcOffset.x = 0;
4407 resolveRegion.srcOffset.y = 0;
4408 resolveRegion.srcOffset.z = 0;
4409 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4410 resolveRegion.dstSubresource.mipLevel = 0;
4411 resolveRegion.dstSubresource.baseArrayLayer = 0;
4412 resolveRegion.dstSubresource.layerCount = 1;
4413 resolveRegion.dstOffset.x = 0;
4414 resolveRegion.dstOffset.y = 0;
4415 resolveRegion.dstOffset.z = 0;
4416 resolveRegion.extent.width = 1;
4417 resolveRegion.extent.height = 1;
4418 resolveRegion.extent.depth = 1;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06004419 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
4420 &resolveRegion);
unknown088160a2019-05-23 17:43:13 -06004421 m_commandBuffer->end();
4422
4423 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06004424}
4425
4426TEST_F(VkLayerTest, ResolveImageLayoutMismatch) {
4427 ASSERT_NO_FATAL_FAILURE(Init());
4428
4429 // Create two images of different types and try to copy between them
4430 VkImageObj srcImage(m_device);
4431 VkImageObj dstImage(m_device);
4432
sfricke-samsung1c61f192021-12-31 01:53:03 -06004433 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004434 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4435 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4436 image_create_info.extent.width = 32;
4437 image_create_info.extent.height = 32;
4438 image_create_info.extent.depth = 1;
4439 image_create_info.mipLevels = 1;
4440 image_create_info.arrayLayers = 1;
sfricke-samsungf46582f2021-03-31 02:02:37 -07004441 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; // guarantee support from sampledImageColorSampleCounts
unknown088160a2019-05-23 17:43:13 -06004442 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4443 image_create_info.usage =
4444 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4445 // Note: Some implementations expect color attachment usage for any
4446 // multisample surface
4447 image_create_info.flags = 0;
4448 srcImage.init(&image_create_info);
4449 ASSERT_TRUE(srcImage.initialized());
4450
4451 // Note: Some implementations expect color attachment usage for any
4452 // multisample surface
4453 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4454 dstImage.init(&image_create_info);
4455 ASSERT_TRUE(dstImage.initialized());
4456
4457 m_commandBuffer->begin();
4458 // source image must have valid contents before resolve
4459 VkClearColorValue clear_color = {{0, 0, 0, 0}};
4460 VkImageSubresourceRange subresource = {};
4461 subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4462 subresource.layerCount = 1;
4463 subresource.levelCount = 1;
4464 srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
4465 m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource);
4466 srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
4467 dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
4468
4469 VkImageResolve resolveRegion;
4470 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4471 resolveRegion.srcSubresource.mipLevel = 0;
4472 resolveRegion.srcSubresource.baseArrayLayer = 0;
4473 resolveRegion.srcSubresource.layerCount = 1;
4474 resolveRegion.srcOffset.x = 0;
4475 resolveRegion.srcOffset.y = 0;
4476 resolveRegion.srcOffset.z = 0;
4477 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4478 resolveRegion.dstSubresource.mipLevel = 0;
4479 resolveRegion.dstSubresource.baseArrayLayer = 0;
4480 resolveRegion.dstSubresource.layerCount = 1;
4481 resolveRegion.dstOffset.x = 0;
4482 resolveRegion.dstOffset.y = 0;
4483 resolveRegion.dstOffset.z = 0;
4484 resolveRegion.extent.width = 1;
4485 resolveRegion.extent.height = 1;
4486 resolveRegion.extent.depth = 1;
4487 // source image layout mismatch
Mark Lobodzinski20310782020-02-28 14:25:17 -07004488 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImageLayout-00260");
unknown088160a2019-05-23 17:43:13 -06004489 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4490 1, &resolveRegion);
4491 m_errorMonitor->VerifyFound();
4492 // dst image layout mismatch
Mark Lobodzinski20310782020-02-28 14:25:17 -07004493 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImageLayout-00262");
unknown088160a2019-05-23 17:43:13 -06004494 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), VK_IMAGE_LAYOUT_GENERAL,
4495 1, &resolveRegion);
4496 m_errorMonitor->VerifyFound();
4497 m_commandBuffer->end();
4498}
4499
4500TEST_F(VkLayerTest, ResolveInvalidSubresource) {
Jeff Leger465acf52020-10-12 18:07:16 -04004501 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
4502
4503 bool copy_commands2 = false;
4504 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME)) {
4505 m_device_extension_names.push_back(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME);
4506 copy_commands2 = true;
4507 }
4508 ASSERT_NO_FATAL_FAILURE(InitState());
4509
4510 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2Function = nullptr;
4511 if (copy_commands2) {
4512 vkCmdResolveImage2Function = (PFN_vkCmdResolveImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdResolveImage2KHR");
4513 }
unknown088160a2019-05-23 17:43:13 -06004514
4515 // Create two images of different types and try to copy between them
4516 VkImageObj srcImage(m_device);
4517 VkImageObj dstImage(m_device);
4518
sfricke-samsung1c61f192021-12-31 01:53:03 -06004519 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004520 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4521 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
4522 image_create_info.extent.width = 32;
4523 image_create_info.extent.height = 32;
4524 image_create_info.extent.depth = 1;
4525 image_create_info.mipLevels = 1;
4526 image_create_info.arrayLayers = 1;
sfricke-samsungf46582f2021-03-31 02:02:37 -07004527 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; // guarantee support from sampledImageColorSampleCounts
unknown088160a2019-05-23 17:43:13 -06004528 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4529 image_create_info.usage =
4530 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4531 // Note: Some implementations expect color attachment usage for any
4532 // multisample surface
4533 image_create_info.flags = 0;
4534 srcImage.init(&image_create_info);
4535 ASSERT_TRUE(srcImage.initialized());
4536
4537 // Note: Some implementations expect color attachment usage for any
4538 // multisample surface
4539 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4540 dstImage.init(&image_create_info);
4541 ASSERT_TRUE(dstImage.initialized());
4542
4543 m_commandBuffer->begin();
4544 // source image must have valid contents before resolve
4545 VkClearColorValue clear_color = {{0, 0, 0, 0}};
4546 VkImageSubresourceRange subresource = {};
4547 subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4548 subresource.layerCount = 1;
4549 subresource.levelCount = 1;
4550 srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
4551 m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource);
4552 srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
4553 dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
4554
4555 VkImageResolve resolveRegion;
4556 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4557 resolveRegion.srcSubresource.mipLevel = 0;
4558 resolveRegion.srcSubresource.baseArrayLayer = 0;
4559 resolveRegion.srcSubresource.layerCount = 1;
4560 resolveRegion.srcOffset.x = 0;
4561 resolveRegion.srcOffset.y = 0;
4562 resolveRegion.srcOffset.z = 0;
4563 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4564 resolveRegion.dstSubresource.mipLevel = 0;
4565 resolveRegion.dstSubresource.baseArrayLayer = 0;
4566 resolveRegion.dstSubresource.layerCount = 1;
4567 resolveRegion.dstOffset.x = 0;
4568 resolveRegion.dstOffset.y = 0;
4569 resolveRegion.dstOffset.z = 0;
4570 resolveRegion.extent.width = 1;
4571 resolveRegion.extent.height = 1;
4572 resolveRegion.extent.depth = 1;
4573 // invalid source mip level
4574 resolveRegion.srcSubresource.mipLevel = image_create_info.mipLevels;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004575 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01709");
unknown088160a2019-05-23 17:43:13 -06004576 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
4577 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
4578 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04004579
4580 // Equivalent test using KHR_copy_commands2
4581 if (copy_commands2 && vkCmdResolveImage2Function) {
4582 const VkImageResolve2KHR resolveRegion2 = {VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
4583 NULL,
4584 resolveRegion.srcSubresource,
4585 resolveRegion.srcOffset,
4586 resolveRegion.dstSubresource,
4587 resolveRegion.dstOffset,
4588 resolveRegion.extent};
4589 const VkResolveImageInfo2KHR resolve_image_info2 = {VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
4590 NULL,
4591 srcImage.image(),
4592 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4593 dstImage.image(),
4594 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4595 1,
4596 &resolveRegion2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07004597 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkResolveImageInfo2-srcSubresource-01709");
Jeff Leger465acf52020-10-12 18:07:16 -04004598 vkCmdResolveImage2Function(m_commandBuffer->handle(), &resolve_image_info2);
4599 m_errorMonitor->VerifyFound();
4600 }
4601
unknown088160a2019-05-23 17:43:13 -06004602 resolveRegion.srcSubresource.mipLevel = 0;
4603 // invalid dest mip level
4604 resolveRegion.dstSubresource.mipLevel = image_create_info.mipLevels;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004605 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01710");
unknown088160a2019-05-23 17:43:13 -06004606 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
4607 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
4608 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04004609
4610 // Equivalent test using KHR_copy_commands2
4611 if (copy_commands2 && vkCmdResolveImage2Function) {
4612 const VkImageResolve2KHR resolveRegion2 = {VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
4613 NULL,
4614 resolveRegion.srcSubresource,
4615 resolveRegion.srcOffset,
4616 resolveRegion.dstSubresource,
4617 resolveRegion.dstOffset,
4618 resolveRegion.extent};
4619 const VkResolveImageInfo2KHR resolve_image_info2 = {VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
4620 NULL,
4621 srcImage.image(),
4622 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4623 dstImage.image(),
4624 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4625 1,
4626 &resolveRegion2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07004627 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkResolveImageInfo2-dstSubresource-01710");
Jeff Leger465acf52020-10-12 18:07:16 -04004628 vkCmdResolveImage2Function(m_commandBuffer->handle(), &resolve_image_info2);
4629 m_errorMonitor->VerifyFound();
4630 }
4631
unknown088160a2019-05-23 17:43:13 -06004632 resolveRegion.dstSubresource.mipLevel = 0;
4633 // invalid source array layer range
4634 resolveRegion.srcSubresource.baseArrayLayer = image_create_info.arrayLayers;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004635 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01711");
unknown088160a2019-05-23 17:43:13 -06004636 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
4637 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
4638 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04004639
4640 // Equivalent test using KHR_copy_commands2
4641 if (copy_commands2 && vkCmdResolveImage2Function) {
4642 const VkImageResolve2KHR resolveRegion2 = {VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
4643 NULL,
4644 resolveRegion.srcSubresource,
4645 resolveRegion.srcOffset,
4646 resolveRegion.dstSubresource,
4647 resolveRegion.dstOffset,
4648 resolveRegion.extent};
4649 const VkResolveImageInfo2KHR resolve_image_info2 = {VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
4650 NULL,
4651 srcImage.image(),
4652 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4653 dstImage.image(),
4654 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4655 1,
4656 &resolveRegion2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07004657 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkResolveImageInfo2-srcSubresource-01711");
Jeff Leger465acf52020-10-12 18:07:16 -04004658 vkCmdResolveImage2Function(m_commandBuffer->handle(), &resolve_image_info2);
4659 m_errorMonitor->VerifyFound();
4660 }
4661
unknown088160a2019-05-23 17:43:13 -06004662 resolveRegion.srcSubresource.baseArrayLayer = 0;
4663 // invalid dest array layer range
4664 resolveRegion.dstSubresource.baseArrayLayer = image_create_info.arrayLayers;
Mark Lobodzinski20310782020-02-28 14:25:17 -07004665 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01712");
unknown088160a2019-05-23 17:43:13 -06004666 m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
4667 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
4668 m_errorMonitor->VerifyFound();
Jeff Leger465acf52020-10-12 18:07:16 -04004669
4670 // Equivalent test using KHR_copy_commands2
4671 if (copy_commands2 && vkCmdResolveImage2Function) {
4672 const VkImageResolve2KHR resolveRegion2 = {VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
4673 NULL,
4674 resolveRegion.srcSubresource,
4675 resolveRegion.srcOffset,
4676 resolveRegion.dstSubresource,
4677 resolveRegion.dstOffset,
4678 resolveRegion.extent};
4679 const VkResolveImageInfo2KHR resolve_image_info2 = {VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
4680 NULL,
4681 srcImage.image(),
4682 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4683 dstImage.image(),
4684 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4685 1,
4686 &resolveRegion2};
Tony-LunarG953d55a2021-11-11 14:20:25 -07004687 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkResolveImageInfo2-dstSubresource-01712");
Jeff Leger465acf52020-10-12 18:07:16 -04004688 vkCmdResolveImage2Function(m_commandBuffer->handle(), &resolve_image_info2);
4689 m_errorMonitor->VerifyFound();
4690 }
4691
unknown088160a2019-05-23 17:43:13 -06004692 resolveRegion.dstSubresource.baseArrayLayer = 0;
4693
4694 m_commandBuffer->end();
4695}
4696
sfricke-samsungf78d0592020-06-11 21:34:44 -07004697TEST_F(VkLayerTest, ResolveImageImageType) {
4698 ASSERT_NO_FATAL_FAILURE(Init());
4699 // Create images of different types and try to resolve between them
4700 VkImageObj srcImage2D(m_device);
4701 VkImageObj dstImage1D(m_device);
4702 VkImageObj dstImage3D(m_device);
4703
sfricke-samsung1c61f192021-12-31 01:53:03 -06004704 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
sfricke-samsungf78d0592020-06-11 21:34:44 -07004705 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
4706 image_create_info.extent.width = 32;
4707 image_create_info.extent.height = 1;
4708 image_create_info.extent.depth = 1;
4709 image_create_info.mipLevels = 1;
4710 image_create_info.arrayLayers = 4; // more than 1 to not trip other validation
sfricke-samsungf46582f2021-03-31 02:02:37 -07004711 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; // guarantee support from sampledImageColorSampleCounts
sfricke-samsungf78d0592020-06-11 21:34:44 -07004712 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4713 image_create_info.usage =
4714 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4715 // Note: Some implementations expect color attachment usage for any
4716 // multisample surface
4717 image_create_info.flags = 0;
4718
4719 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4720 srcImage2D.init(&image_create_info);
4721 ASSERT_TRUE(srcImage2D.initialized());
4722
4723 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4724 image_create_info.imageType = VK_IMAGE_TYPE_1D;
4725 dstImage1D.init(&image_create_info);
4726 ASSERT_TRUE(dstImage1D.initialized());
4727
4728 image_create_info.imageType = VK_IMAGE_TYPE_3D;
4729 image_create_info.extent.height = 16;
4730 image_create_info.extent.depth = 16;
4731 image_create_info.arrayLayers = 1;
4732 dstImage3D.init(&image_create_info);
4733 ASSERT_TRUE(dstImage3D.initialized());
4734
4735 m_commandBuffer->begin();
4736
4737 VkImageResolve resolveRegion;
4738 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4739 resolveRegion.srcSubresource.mipLevel = 0;
4740 resolveRegion.srcSubresource.baseArrayLayer = 0;
4741 resolveRegion.srcSubresource.layerCount = 1;
4742 resolveRegion.srcOffset.x = 0;
4743 resolveRegion.srcOffset.y = 0;
4744 resolveRegion.srcOffset.z = 0;
4745 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4746 resolveRegion.dstSubresource.mipLevel = 0;
4747 resolveRegion.dstSubresource.baseArrayLayer = 0;
4748 resolveRegion.dstSubresource.layerCount = 1;
4749 resolveRegion.dstOffset.x = 0;
4750 resolveRegion.dstOffset.y = 0;
4751 resolveRegion.dstOffset.z = 0;
4752 resolveRegion.extent.width = 1;
4753 resolveRegion.extent.height = 1;
4754 resolveRegion.extent.depth = 1;
4755
4756 // non-zero value baseArrayLayer
4757 resolveRegion.srcSubresource.baseArrayLayer = 2;
Shannon McPherson74b341c2020-09-08 15:43:05 -06004758 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-04446");
sfricke-samsungf78d0592020-06-11 21:34:44 -07004759 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4760 &resolveRegion);
4761 m_errorMonitor->VerifyFound();
4762 resolveRegion.srcSubresource.baseArrayLayer = 0;
4763
4764 // Set height with 1D dstImage
4765 resolveRegion.extent.height = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004766 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-00276");
sfricke-samsungdfeb3172020-07-25 21:17:07 -07004767 // Also exceed height of both images
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004768 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcOffset-00270");
4769 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstOffset-00275");
sfricke-samsungf78d0592020-06-11 21:34:44 -07004770 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4771 &resolveRegion);
4772 m_errorMonitor->VerifyFound();
4773 resolveRegion.extent.height = 1;
4774
4775 // Set depth with 1D dstImage and 2D srcImage
4776 resolveRegion.extent.depth = 2;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004777 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-00278");
4778 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-00273");
sfricke-samsungf78d0592020-06-11 21:34:44 -07004779 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4780 &resolveRegion);
4781 m_errorMonitor->VerifyFound();
4782 resolveRegion.extent.depth = 1;
4783
4784 m_commandBuffer->end();
4785}
4786
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004787TEST_F(VkLayerTest, ResolveImageSizeExceeded) {
4788 TEST_DESCRIPTION("Resolve Image with subresource region greater than size of src/dst image");
4789 ASSERT_NO_FATAL_FAILURE(Init());
4790
4791 VkImageObj srcImage2D(m_device);
4792 VkImageObj dstImage2D(m_device);
4793
sfricke-samsung1c61f192021-12-31 01:53:03 -06004794 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004795 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
4796 image_create_info.extent.width = 32;
4797 image_create_info.extent.height = 32;
4798 image_create_info.extent.depth = 1;
Tony-LunarG0f8f94b2021-06-01 13:23:09 -06004799 image_create_info.mipLevels = 1;
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004800 image_create_info.arrayLayers = 1;
4801 image_create_info.samples = VK_SAMPLE_COUNT_4_BIT;
4802 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4803 image_create_info.usage =
4804 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4805 // Note: Some implementations expect color attachment usage for any
4806 // multisample surface
4807 image_create_info.flags = 0;
4808
4809 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4810 srcImage2D.init(&image_create_info);
4811 ASSERT_TRUE(srcImage2D.initialized());
4812
4813 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4814 dstImage2D.init(&image_create_info);
4815 ASSERT_TRUE(dstImage2D.initialized());
4816
4817 m_commandBuffer->begin();
4818
4819 VkImageResolve resolveRegion = {};
4820 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4821 resolveRegion.srcSubresource.mipLevel = 0;
4822 resolveRegion.srcSubresource.baseArrayLayer = 0;
4823 resolveRegion.srcSubresource.layerCount = 1;
4824 resolveRegion.srcOffset.x = 0;
4825 resolveRegion.srcOffset.y = 0;
4826 resolveRegion.srcOffset.z = 0;
4827 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4828 resolveRegion.dstSubresource.mipLevel = 0;
4829 resolveRegion.dstSubresource.baseArrayLayer = 0;
4830 resolveRegion.dstSubresource.layerCount = 1;
4831 resolveRegion.dstOffset.x = 0;
4832 resolveRegion.dstOffset.y = 0;
4833 resolveRegion.dstOffset.z = 0;
4834 resolveRegion.extent.width = 32;
4835 resolveRegion.extent.height = 32;
4836 resolveRegion.extent.depth = 1;
4837
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004838 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4839 &resolveRegion);
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004840
4841 // srcImage exceeded in x-dim
4842 resolveRegion.srcOffset.x = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004843 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcOffset-00269");
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004844 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4845 &resolveRegion);
4846 m_errorMonitor->VerifyFound();
4847 resolveRegion.srcOffset.x = 0;
4848
4849 // dstImage exceeded in x-dim
4850 resolveRegion.dstOffset.x = 4;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004851 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstOffset-00274");
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004852 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4853 &resolveRegion);
4854 m_errorMonitor->VerifyFound();
4855 resolveRegion.dstOffset.x = 0;
4856
Tony-LunarG0f8f94b2021-06-01 13:23:09 -06004857 // both image exceeded in y-dim
4858 resolveRegion.srcOffset.y = 32;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004859 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcOffset-00270");
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004860 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4861 &resolveRegion);
4862 m_errorMonitor->VerifyFound();
Tony-LunarG0f8f94b2021-06-01 13:23:09 -06004863 resolveRegion.srcOffset.y = 0;
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004864
Tony-LunarG0f8f94b2021-06-01 13:23:09 -06004865 resolveRegion.dstOffset.y = 32;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004866 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstOffset-00275");
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004867 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4868 &resolveRegion);
4869 m_errorMonitor->VerifyFound();
Tony-LunarG0f8f94b2021-06-01 13:23:09 -06004870 resolveRegion.dstOffset.y = 0;
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004871
4872 // srcImage exceeded in z-dim
4873 resolveRegion.srcOffset.z = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004874 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcOffset-00272");
4875 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-00273"); // because it's a 2d image
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004876 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4877 &resolveRegion);
4878 m_errorMonitor->VerifyFound();
4879 resolveRegion.srcOffset.z = 0;
4880
4881 // dstImage exceeded in z-dim
4882 resolveRegion.dstOffset.z = 1;
Shannon McPherson2c793ba2020-08-28 12:13:24 -06004883 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstOffset-00277");
4884 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-00278"); // because it's a 2d image
sfricke-samsungc967a2d2020-07-25 21:17:16 -07004885 m_commandBuffer->ResolveImage(srcImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
4886 &resolveRegion);
4887 m_errorMonitor->VerifyFound();
4888 resolveRegion.dstOffset.z = 0;
4889
4890 m_commandBuffer->end();
4891}
4892
unknown088160a2019-05-23 17:43:13 -06004893TEST_F(VkLayerTest, ClearImageErrors) {
4894 TEST_DESCRIPTION("Call ClearColorImage w/ a depth|stencil image and ClearDepthStencilImage with a color image.");
4895
4896 ASSERT_NO_FATAL_FAILURE(Init());
4897 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
4898
4899 m_commandBuffer->begin();
4900
4901 // Color image
4902 VkClearColorValue clear_color;
4903 memset(clear_color.uint32, 0, sizeof(uint32_t) * 4);
4904 const VkFormat color_format = VK_FORMAT_B8G8R8A8_UNORM;
4905 const int32_t img_width = 32;
4906 const int32_t img_height = 32;
sfricke-samsung1c61f192021-12-31 01:53:03 -06004907 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06004908 image_create_info.imageType = VK_IMAGE_TYPE_2D;
4909 image_create_info.format = color_format;
4910 image_create_info.extent.width = img_width;
4911 image_create_info.extent.height = img_height;
4912 image_create_info.extent.depth = 1;
4913 image_create_info.mipLevels = 1;
4914 image_create_info.arrayLayers = 1;
4915 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
4916 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4917
4918 image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
4919 vk_testing::Image color_image_no_transfer;
4920 color_image_no_transfer.init(*m_device, image_create_info);
4921
4922 image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4923 vk_testing::Image color_image;
4924 color_image.init(*m_device, image_create_info);
4925
4926 const VkImageSubresourceRange color_range = vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_COLOR_BIT);
4927
4928 // Depth/Stencil image
4929 VkClearDepthStencilValue clear_value = {0};
4930 VkImageCreateInfo ds_image_create_info = vk_testing::Image::create_info();
4931 ds_image_create_info.imageType = VK_IMAGE_TYPE_2D;
4932 ds_image_create_info.format = VK_FORMAT_D16_UNORM;
4933 ds_image_create_info.extent.width = 64;
4934 ds_image_create_info.extent.height = 64;
4935 ds_image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
4936 ds_image_create_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4937
4938 vk_testing::Image ds_image;
4939 ds_image.init(*m_device, ds_image_create_info);
4940
4941 const VkImageSubresourceRange ds_range = vk_testing::Image::subresource_range(ds_image_create_info, VK_IMAGE_ASPECT_DEPTH_BIT);
4942
sfricke-samsungcd924d92020-05-20 23:51:17 -07004943 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00007");
unknown088160a2019-05-23 17:43:13 -06004944
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004945 vk::CmdClearColorImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1, &color_range);
unknown088160a2019-05-23 17:43:13 -06004946
4947 m_errorMonitor->VerifyFound();
4948
sfricke-samsungcd924d92020-05-20 23:51:17 -07004949 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00002");
unknown088160a2019-05-23 17:43:13 -06004950
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004951 vk::CmdClearColorImage(m_commandBuffer->handle(), color_image_no_transfer.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1,
4952 &color_range);
unknown088160a2019-05-23 17:43:13 -06004953
4954 m_errorMonitor->VerifyFound();
4955
4956 // Call CmdClearDepthStencilImage with color image
sfricke-samsungcd924d92020-05-20 23:51:17 -07004957 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-image-00014");
sfricke-samsung30e325a2020-07-25 12:56:13 -07004958 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-image-02826");
unknown088160a2019-05-23 17:43:13 -06004959
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004960 vk::CmdClearDepthStencilImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4961 &clear_value, 1, &ds_range);
unknown088160a2019-05-23 17:43:13 -06004962
4963 m_errorMonitor->VerifyFound();
4964}
4965
4966TEST_F(VkLayerTest, CommandQueueFlags) {
4967 TEST_DESCRIPTION(
4968 "Allocate a command buffer on a queue that does not support graphics and try to issue a graphics-only command");
4969
4970 ASSERT_NO_FATAL_FAILURE(Init());
4971
4972 uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT);
4973 if (queueFamilyIndex == UINT32_MAX) {
4974 printf("%s Non-graphics queue family not found; skipped.\n", kSkipPrefix);
4975 return;
4976 } else {
4977 // Create command pool on a non-graphics queue
4978 VkCommandPoolObj command_pool(m_device, queueFamilyIndex);
4979
4980 // Setup command buffer on pool
4981 VkCommandBufferObj command_buffer(m_device, &command_pool);
4982 command_buffer.begin();
4983
4984 // Issue a graphics only command
Mark Lobodzinski20310782020-02-28 14:25:17 -07004985 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-commandBuffer-cmdpool");
unknown088160a2019-05-23 17:43:13 -06004986 VkViewport viewport = {0, 0, 16, 16, 0, 1};
4987 command_buffer.SetViewport(0, 1, &viewport);
4988 m_errorMonitor->VerifyFound();
4989 }
4990}
4991
sfricke-samsung674ba102020-08-18 22:38:49 -07004992TEST_F(VkLayerTest, DepthStencilImageCopyNoGraphicsQueueFlags) {
4993 TEST_DESCRIPTION(
4994 "Allocate a command buffer on a queue that does not support graphics and try to issue a depth/stencil image copy to "
4995 "buffer");
4996
4997 ASSERT_NO_FATAL_FAILURE(Init());
4998
4999 uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT);
5000 if (queueFamilyIndex == UINT32_MAX) {
5001 printf("%s Non-graphics queue family not found; skipped.\n", kSkipPrefix);
5002 return;
5003 } else {
5004 // Create Depth image
5005 const VkFormat ds_format = FindSupportedDepthOnlyFormat(gpu());
5006 if (ds_format == VK_FORMAT_UNDEFINED) {
5007 printf("%s No only Depth format found. Skipped.\n", kSkipPrefix);
5008 return;
5009 }
5010
5011 VkImageObj ds_image(m_device);
5012 ds_image.Init(64, 64, 1, ds_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
5013 VK_IMAGE_TILING_OPTIMAL, 0);
5014 ASSERT_TRUE(ds_image.initialized());
5015
5016 // Allocate buffers
5017 VkBufferObj buffer;
5018 VkMemoryPropertyFlags reqs = 0;
5019 buffer.init_as_src_and_dst(*m_device, 262144, reqs); // 256k to have more then enough to copy
5020
5021 VkBufferImageCopy region = {};
5022 region.bufferRowLength = 0;
5023 region.bufferImageHeight = 0;
5024 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
5025 region.imageSubresource.layerCount = 1;
5026 region.imageOffset = {0, 0, 0};
5027 region.imageExtent = {64, 64, 1};
5028 region.bufferOffset = 0;
5029
5030 // Create command pool on a non-graphics queue
5031 VkCommandPoolObj command_pool(m_device, queueFamilyIndex);
5032
5033 // Setup command buffer on pool
5034 VkCommandBufferObj command_buffer(m_device, &command_pool);
5035 command_buffer.begin();
5036
sfricke-samsungea4fd142020-10-17 23:51:59 -07005037 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-04477");
sfricke-samsung674ba102020-08-18 22:38:49 -07005038 vk::CmdCopyBufferToImage(command_buffer.handle(), buffer.handle(), ds_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5039 1, &region);
5040 m_errorMonitor->VerifyFound();
5041 }
5042}
5043
sfricke-samsung5a019492021-01-25 10:32:08 -08005044TEST_F(VkLayerTest, ImageCopyTransferQueueFlags) {
5045 TEST_DESCRIPTION(
5046 "Allocate a command buffer on a queue that does not support graphics/compute and try to issue an invalid image copy to "
5047 "buffer");
5048
5049 ASSERT_NO_FATAL_FAILURE(Init());
5050
5051 // Should be left with a tranfser queue
5052 uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT);
5053 if (queueFamilyIndex == UINT32_MAX) {
5054 printf("%s Non-graphics/compute queue family not found; skipped.\n", kSkipPrefix);
5055 return;
5056 }
5057
5058 VkImageObj image(m_device);
5059 image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
5060 VK_IMAGE_TILING_OPTIMAL, 0);
5061 ASSERT_TRUE(image.initialized());
5062
5063 // Allocate buffers
5064 VkBufferObj buffer;
5065 VkMemoryPropertyFlags reqs = 0;
5066 buffer.init_as_src_and_dst(*m_device, 262144, reqs); // 256k to have more then enough to copy
5067
5068 VkBufferImageCopy region = {};
5069 region.bufferRowLength = 0;
5070 region.bufferImageHeight = 0;
5071 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
5072 region.imageSubresource.layerCount = 1;
5073 region.imageOffset = {0, 0, 0};
5074 region.imageExtent = {16, 16, 1};
5075 region.bufferOffset = 5;
5076
5077 // Create command pool on a non-graphics queue
5078 VkCommandPoolObj command_pool(m_device, queueFamilyIndex);
5079
5080 // Setup command buffer on pool
5081 VkCommandBufferObj command_buffer(m_device, &command_pool);
5082 command_buffer.begin();
5083
5084 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-bufferOffset-00193");
5085 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-04052");
5086 vk::CmdCopyBufferToImage(command_buffer.handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
5087 &region);
5088 m_errorMonitor->VerifyFound();
5089}
5090
sfricke-samsungcb467672020-11-25 00:09:28 -08005091TEST_F(VkLayerTest, ExecuteDiffertQueueFlagsSecondaryCB) {
5092 TEST_DESCRIPTION("Allocate a command buffer from two different queues and try to use a secondary command buffer");
5093
5094 ASSERT_NO_FATAL_FAILURE(Init());
5095
5096 if (m_device->queue_props.size() < 2) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005097 GTEST_SKIP() << "Need 2 different queues for testing skipping.";
sfricke-samsungcb467672020-11-25 00:09:28 -08005098 }
5099
5100 // First two queue families
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005101 uint32_t queue_index_a = 0;
5102 uint32_t queue_index_b = 1;
sfricke-samsungcb467672020-11-25 00:09:28 -08005103
sfricke-samsung1c61f192021-12-31 01:53:03 -06005104 VkCommandPoolCreateInfo pool_create_info = LvlInitStruct<VkCommandPoolCreateInfo>();
sfricke-samsungcb467672020-11-25 00:09:28 -08005105 pool_create_info.flags = 0;
5106
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005107 pool_create_info.queueFamilyIndex = queue_index_a;
5108 vk_testing::CommandPool command_pool_a(*m_device, pool_create_info);
5109 ASSERT_TRUE(command_pool_a.initialized());
sfricke-samsungcb467672020-11-25 00:09:28 -08005110
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005111 pool_create_info.queueFamilyIndex = queue_index_b;
5112 vk_testing::CommandPool command_pool_b(*m_device, pool_create_info);
5113 ASSERT_TRUE(command_pool_b.initialized());
sfricke-samsungcb467672020-11-25 00:09:28 -08005114
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005115 auto command_buffer_allocate_info = LvlInitStruct<VkCommandBufferAllocateInfo>();
sfricke-samsungcb467672020-11-25 00:09:28 -08005116 command_buffer_allocate_info.commandBufferCount = 1;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005117 command_buffer_allocate_info.commandPool = command_pool_a.handle();
sfricke-samsungcb467672020-11-25 00:09:28 -08005118 command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005119 vk_testing::CommandBuffer command_buffer_primary(*m_device, command_buffer_allocate_info);
5120 ASSERT_TRUE(command_buffer_primary.initialized());
sfricke-samsungcb467672020-11-25 00:09:28 -08005121
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005122 command_buffer_allocate_info.commandPool = command_pool_b.handle();
sfricke-samsungcb467672020-11-25 00:09:28 -08005123 command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005124 vk_testing::CommandBuffer command_buffer_secondary(*m_device, command_buffer_allocate_info);
sfricke-samsungcb467672020-11-25 00:09:28 -08005125
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005126 auto cmdbuff_ii = LvlInitStruct<VkCommandBufferInheritanceInfo>();
5127 cmdbuff_ii.renderPass = m_renderPass;
5128 cmdbuff_ii.subpass = 0;
5129 cmdbuff_ii.framebuffer = m_framebuffer;
5130
5131 auto begin_info = LvlInitStruct<VkCommandBufferBeginInfo>();
5132 begin_info.pInheritanceInfo = &cmdbuff_ii;
sfricke-samsungcb467672020-11-25 00:09:28 -08005133
5134 // secondary
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005135 command_buffer_secondary.begin(&begin_info);
5136 command_buffer_secondary.end();
sfricke-samsungcb467672020-11-25 00:09:28 -08005137
5138 // Try using different pool's command buffer as secondary
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005139 command_buffer_primary.begin(&begin_info);
sfricke-samsungcb467672020-11-25 00:09:28 -08005140 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00094");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005141 vk::CmdExecuteCommands(command_buffer_primary.handle(), 1, &command_buffer_secondary.handle());
sfricke-samsungcb467672020-11-25 00:09:28 -08005142 m_errorMonitor->VerifyFound();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06005143 command_buffer_primary.end();
sfricke-samsungcb467672020-11-25 00:09:28 -08005144}
5145
unknown088160a2019-05-23 17:43:13 -06005146TEST_F(VkLayerTest, ExecuteUnrecordedSecondaryCB) {
5147 TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB in the initial state");
5148 ASSERT_NO_FATAL_FAILURE(Init());
5149 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
5150 // never record secondary
5151
Mark Lobodzinski20310782020-02-28 14:25:17 -07005152 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00089");
unknown088160a2019-05-23 17:43:13 -06005153 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005154 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06005155 m_errorMonitor->VerifyFound();
5156 m_commandBuffer->end();
5157}
5158
5159TEST_F(VkLayerTest, ExecuteSecondaryCBWithLayoutMismatch) {
5160 TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB with incorrect initial layout.");
5161
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005162 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06005163 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
5164
sfricke-samsung1c61f192021-12-31 01:53:03 -06005165 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06005166 image_create_info.imageType = VK_IMAGE_TYPE_2D;
5167 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
5168 image_create_info.extent.width = 32;
5169 image_create_info.extent.height = 1;
5170 image_create_info.extent.depth = 1;
5171 image_create_info.mipLevels = 1;
5172 image_create_info.arrayLayers = 1;
5173 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
5174 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
5175 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
5176 image_create_info.flags = 0;
5177
5178 VkImageSubresource image_sub = VkImageObj::subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0);
5179 VkImageSubresourceRange image_sub_range = VkImageObj::subresource_range(image_sub);
5180
5181 VkImageObj image(m_device);
5182 image.init(&image_create_info);
5183 ASSERT_TRUE(image.initialized());
5184 VkImageMemoryBarrier image_barrier =
5185 image.image_memory_barrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, image_sub_range);
5186
5187 auto pipeline = [&image_barrier](const VkCommandBufferObj &cb, VkImageLayout old_layout, VkImageLayout new_layout) {
5188 image_barrier.oldLayout = old_layout;
5189 image_barrier.newLayout = new_layout;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005190 vk::CmdPipelineBarrier(cb.handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr,
5191 0, nullptr, 1, &image_barrier);
unknown088160a2019-05-23 17:43:13 -06005192 };
5193
5194 // Validate that mismatched use of image layout in secondary command buffer is caught at record time
5195 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
5196 secondary.begin();
5197 pipeline(secondary, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
5198 secondary.end();
5199
Mark Lobodzinski20310782020-02-28 14:25:17 -07005200 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-vkCmdExecuteCommands-commandBuffer-00001");
unknown088160a2019-05-23 17:43:13 -06005201 m_commandBuffer->begin();
5202 pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005203 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06005204 m_errorMonitor->VerifyFound();
5205
unknown088160a2019-05-23 17:43:13 -06005206 m_commandBuffer->reset();
5207 secondary.reset();
5208
5209 // Validate that UNDEFINED doesn't false positive on us
5210 secondary.begin();
5211 pipeline(secondary, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
5212 secondary.end();
5213 m_commandBuffer->begin();
5214 pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005215 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06005216 m_commandBuffer->end();
5217}
5218
5219TEST_F(VkLayerTest, SetDynViewportParamTests) {
5220 TEST_DESCRIPTION("Test parameters of vkCmdSetViewport without multiViewport feature");
5221
5222 SetTargetApiVersion(VK_API_VERSION_1_1);
5223 VkPhysicalDeviceFeatures features{};
5224 ASSERT_NO_FATAL_FAILURE(Init(&features));
5225
5226 const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0};
5227 const VkViewport viewports[] = {vp, vp};
5228
5229 m_commandBuffer->begin();
5230
5231 // array tests
Mark Lobodzinski20310782020-02-28 14:25:17 -07005232 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005233 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 1, viewports);
unknown088160a2019-05-23 17:43:13 -06005234 m_errorMonitor->VerifyFound();
5235
Mark Lobodzinski20310782020-02-28 14:25:17 -07005236 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005237 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06005238 m_errorMonitor->VerifyFound();
5239
Mark Lobodzinski20310782020-02-28 14:25:17 -07005240 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005241 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 2, viewports);
unknown088160a2019-05-23 17:43:13 -06005242 m_errorMonitor->VerifyFound();
5243
Mark Lobodzinski20310782020-02-28 14:25:17 -07005244 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224");
5245 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005246 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 2, viewports);
unknown088160a2019-05-23 17:43:13 -06005247 m_errorMonitor->VerifyFound();
5248
Mark Lobodzinski20310782020-02-28 14:25:17 -07005249 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005250 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, nullptr);
unknown088160a2019-05-23 17:43:13 -06005251 m_errorMonitor->VerifyFound();
5252
5253 // core viewport tests
5254 using std::vector;
5255 struct TestCase {
5256 VkViewport vp;
5257 std::string veid;
5258 };
5259
5260 // not necessarily boundary values (unspecified cast rounding), but guaranteed to be over limit
5261 const auto one_past_max_w = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[0]));
5262 const auto one_past_max_h = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[1]));
5263
5264 const auto min_bound = m_device->props.limits.viewportBoundsRange[0];
5265 const auto max_bound = m_device->props.limits.viewportBoundsRange[1];
5266 const auto one_before_min_bounds = NearestSmaller(min_bound);
5267 const auto one_past_max_bounds = NearestGreater(max_bound);
5268
5269 const auto below_zero = NearestSmaller(0.0f);
5270 const auto past_one = NearestGreater(1.0f);
5271
5272 vector<TestCase> test_cases = {
5273 {{0.0, 0.0, 0.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"},
5274 {{0.0, 0.0, one_past_max_w, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01771"},
5275 {{0.0, 0.0, NAN, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"},
5276 {{0.0, 0.0, 64.0, one_past_max_h, 0.0, 1.0}, "VUID-VkViewport-height-01773"},
5277 {{one_before_min_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"},
5278 {{one_past_max_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"},
5279 {{NAN, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"},
5280 {{0.0, one_before_min_bounds, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"},
5281 {{0.0, NAN, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"},
5282 {{max_bound, 0.0, 1.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"},
5283 {{0.0, max_bound, 64.0, 1.0, 0.0, 1.0}, "VUID-VkViewport-y-01233"},
5284 {{0.0, 0.0, 64.0, 64.0, below_zero, 1.0}, "VUID-VkViewport-minDepth-01234"},
5285 {{0.0, 0.0, 64.0, 64.0, past_one, 1.0}, "VUID-VkViewport-minDepth-01234"},
5286 {{0.0, 0.0, 64.0, 64.0, NAN, 1.0}, "VUID-VkViewport-minDepth-01234"},
5287 {{0.0, 0.0, 64.0, 64.0, 0.0, below_zero}, "VUID-VkViewport-maxDepth-01235"},
5288 {{0.0, 0.0, 64.0, 64.0, 0.0, past_one}, "VUID-VkViewport-maxDepth-01235"},
5289 {{0.0, 0.0, 64.0, 64.0, 0.0, NAN}, "VUID-VkViewport-maxDepth-01235"},
5290 };
5291
5292 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
5293 test_cases.push_back({{0.0, 0.0, 64.0, 0.0, 0.0, 1.0}, "VUID-VkViewport-height-01772"});
5294 test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01772"});
5295 } else {
5296 test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01773"});
5297 }
5298
5299 for (const auto &test_case : test_cases) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07005300 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.veid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005301 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &test_case.vp);
unknown088160a2019-05-23 17:43:13 -06005302 m_errorMonitor->VerifyFound();
5303 }
5304}
5305
5306TEST_F(VkLayerTest, SetDynViewportParamMaintenance1Tests) {
5307 TEST_DESCRIPTION("Verify errors are detected on misuse of SetViewport with a negative viewport extension enabled.");
5308
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005309 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06005310
Mike Schuchardt7cc57842021-09-15 10:49:59 -07005311 if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME)) {
5312 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06005313 } else {
5314 printf("%s VK_KHR_maintenance1 extension not supported -- skipping test\n", kSkipPrefix);
5315 return;
5316 }
5317 ASSERT_NO_FATAL_FAILURE(InitState());
5318
5319 NegHeightViewportTests(m_device, m_commandBuffer, m_errorMonitor);
5320}
5321
5322TEST_F(VkLayerTest, SetDynViewportParamMultiviewportTests) {
5323 TEST_DESCRIPTION("Test parameters of vkCmdSetViewport with multiViewport feature enabled");
5324
5325 ASSERT_NO_FATAL_FAILURE(Init());
5326
5327 if (!m_device->phy().features().multiViewport) {
5328 printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix);
5329 return;
5330 }
5331
unknown088160a2019-05-23 17:43:13 -06005332 m_commandBuffer->begin();
5333
Mark Lobodzinski20310782020-02-28 14:25:17 -07005334 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005335 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06005336 m_errorMonitor->VerifyFound();
5337
Petr Kraus14e49492019-09-09 20:13:29 +02005338 const auto max_viewports = m_device->props.limits.maxViewports;
5339
Mark Lobodzinski20310782020-02-28 14:25:17 -07005340 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005341 vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports, nullptr);
unknown088160a2019-05-23 17:43:13 -06005342 m_errorMonitor->VerifyFound();
5343
Petr Kraus14e49492019-09-09 20:13:29 +02005344 const uint32_t too_big_max_viewports = 65536 + 1; // let's say this is too much to allocate
5345 if (max_viewports >= too_big_max_viewports) {
5346 printf("%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping part of test.\n",
5347 kSkipPrefix);
5348 } else {
5349 const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0};
5350 const std::vector<VkViewport> viewports(max_viewports + 1, vp);
5351
Mark Lobodzinski20310782020-02-28 14:25:17 -07005352 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005353 vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports + 1, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005354 m_errorMonitor->VerifyFound();
5355
Mark Lobodzinski20310782020-02-28 14:25:17 -07005356 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005357 vk::CmdSetViewport(m_commandBuffer->handle(), max_viewports, 1, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005358 m_errorMonitor->VerifyFound();
5359
Mark Lobodzinski20310782020-02-28 14:25:17 -07005360 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005361 vk::CmdSetViewport(m_commandBuffer->handle(), 1, max_viewports, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005362 m_errorMonitor->VerifyFound();
5363
Mark Lobodzinski20310782020-02-28 14:25:17 -07005364 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005365 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005366 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06005367 }
unknown088160a2019-05-23 17:43:13 -06005368}
5369
5370TEST_F(VkLayerTest, BadRenderPassScopeSecondaryCmdBuffer) {
5371 TEST_DESCRIPTION(
5372 "Test secondary buffers executed in wrong render pass scope wrt VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
5373
5374 ASSERT_NO_FATAL_FAILURE(Init());
5375 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5376
5377 VkCommandBufferObj sec_cmdbuff_inside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
5378 VkCommandBufferObj sec_cmdbuff_outside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
5379
5380 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
5381 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
5382 nullptr, // pNext
5383 m_renderPass,
5384 0, // subpass
5385 m_framebuffer,
5386 };
5387 const VkCommandBufferBeginInfo cmdbuff_bi_tmpl = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
5388 nullptr, // pNext
5389 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
5390
5391 VkCommandBufferBeginInfo cmdbuff_inside_rp_bi = cmdbuff_bi_tmpl;
5392 cmdbuff_inside_rp_bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
5393 sec_cmdbuff_inside_rp.begin(&cmdbuff_inside_rp_bi);
5394 sec_cmdbuff_inside_rp.end();
5395
5396 VkCommandBufferBeginInfo cmdbuff_outside_rp_bi = cmdbuff_bi_tmpl;
5397 cmdbuff_outside_rp_bi.flags &= ~VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
5398 sec_cmdbuff_outside_rp.begin(&cmdbuff_outside_rp_bi);
5399 sec_cmdbuff_outside_rp.end();
5400
5401 m_commandBuffer->begin();
5402
Mark Lobodzinski20310782020-02-28 14:25:17 -07005403 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00100");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005404 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_inside_rp.handle());
unknown088160a2019-05-23 17:43:13 -06005405 m_errorMonitor->VerifyFound();
5406
5407 const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
5408 nullptr, // pNext
5409 m_renderPass,
5410 m_framebuffer,
5411 {{0, 0}, {32, 32}},
5412 static_cast<uint32_t>(m_renderPassClearValues.size()),
5413 m_renderPassClearValues.data()};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005414 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -06005415
Mark Lobodzinski20310782020-02-28 14:25:17 -07005416 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005417 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_outside_rp.handle());
unknown088160a2019-05-23 17:43:13 -06005418 m_errorMonitor->VerifyFound();
5419}
5420
5421TEST_F(VkLayerTest, SecondaryCommandBufferClearColorAttachmentsRenderArea) {
5422 TEST_DESCRIPTION(
5423 "Create a secondary command buffer with CmdClearAttachments call that has a rect outside of renderPass renderArea");
5424 ASSERT_NO_FATAL_FAILURE(Init());
5425 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5426
sfricke-samsung1c61f192021-12-31 01:53:03 -06005427 VkCommandBufferAllocateInfo command_buffer_allocate_info = LvlInitStruct<VkCommandBufferAllocateInfo>();
unknown088160a2019-05-23 17:43:13 -06005428 command_buffer_allocate_info.commandPool = m_commandPool->handle();
5429 command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
5430 command_buffer_allocate_info.commandBufferCount = 1;
5431
5432 VkCommandBuffer secondary_command_buffer;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005433 ASSERT_VK_SUCCESS(vk::AllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer));
sfricke-samsung1c61f192021-12-31 01:53:03 -06005434 VkCommandBufferBeginInfo command_buffer_begin_info = LvlInitStruct<VkCommandBufferBeginInfo>();
5435 VkCommandBufferInheritanceInfo command_buffer_inheritance_info = LvlInitStruct<VkCommandBufferInheritanceInfo>();
unknown088160a2019-05-23 17:43:13 -06005436 command_buffer_inheritance_info.renderPass = m_renderPass;
5437 command_buffer_inheritance_info.framebuffer = m_framebuffer;
5438
unknown088160a2019-05-23 17:43:13 -06005439 command_buffer_begin_info.flags =
5440 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
5441 command_buffer_begin_info.pInheritanceInfo = &command_buffer_inheritance_info;
5442
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005443 vk::BeginCommandBuffer(secondary_command_buffer, &command_buffer_begin_info);
unknown088160a2019-05-23 17:43:13 -06005444 VkClearAttachment color_attachment;
5445 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
5446 color_attachment.clearValue.color.float32[0] = 0;
5447 color_attachment.clearValue.color.float32[1] = 0;
5448 color_attachment.clearValue.color.float32[2] = 0;
5449 color_attachment.clearValue.color.float32[3] = 0;
5450 color_attachment.colorAttachment = 0;
5451 // x extent of 257 exceeds render area of 256
Mark Lobodzinski62490892019-06-28 09:58:27 -06005452 VkClearRect clear_rect = {{{0, 0}, {257, 32}}, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005453 vk::CmdClearAttachments(secondary_command_buffer, 1, &color_attachment, 1, &clear_rect);
5454 vk::EndCommandBuffer(secondary_command_buffer);
unknown088160a2019-05-23 17:43:13 -06005455 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005456 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -06005457
Mark Lobodzinski20310782020-02-28 14:25:17 -07005458 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-pRects-00016");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005459 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary_command_buffer);
unknown088160a2019-05-23 17:43:13 -06005460 m_errorMonitor->VerifyFound();
5461
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005462 vk::CmdEndRenderPass(m_commandBuffer->handle());
unknown088160a2019-05-23 17:43:13 -06005463 m_commandBuffer->end();
5464}
5465
5466TEST_F(VkLayerTest, PushDescriptorSetCmdPushBadArgs) {
5467 TEST_DESCRIPTION("Attempt to push a push descriptor set with incorrect arguments.");
sjfricked8e01c52022-07-06 14:09:04 +09005468 AddRequiredExtensions(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
unknown088160a2019-05-23 17:43:13 -06005469
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005470 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sjfricked8e01c52022-07-06 14:09:04 +09005471 if (!AreRequiredExtensionsEnabled()) {
5472 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
unknown088160a2019-05-23 17:43:13 -06005473 }
5474 ASSERT_NO_FATAL_FAILURE(InitState());
5475
5476 auto push_descriptor_prop = GetPushDescriptorProperties(instance(), gpu());
5477 if (push_descriptor_prop.maxPushDescriptors < 1) {
5478 // Some implementations report an invalid maxPushDescriptors of 0
5479 printf("%s maxPushDescriptors is zero, skipping tests\n", kSkipPrefix);
5480 return;
5481 }
5482
5483 // Create ordinary and push descriptor set layout
5484 VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr};
5485 const VkDescriptorSetLayoutObj ds_layout(m_device, {binding});
5486 ASSERT_TRUE(ds_layout.initialized());
5487 const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
5488 ASSERT_TRUE(push_ds_layout.initialized());
5489
5490 // Now use the descriptor set layouts to create a pipeline layout
5491 const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout, &ds_layout});
5492 ASSERT_TRUE(pipeline_layout.initialized());
5493
5494 // Create a descriptor to push
5495 const uint32_t buffer_data[4] = {4, 5, 6, 7};
5496 VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data);
5497 ASSERT_TRUE(buffer_obj.initialized());
5498
5499 // Create a "write" struct, noting that the buffer_info cannot be a temporary arg (the return from write_descriptor_set
5500 // references its data), and the DescriptorSet() can be temporary, because the value is ignored
5501 VkDescriptorBufferInfo buffer_info = {buffer_obj.handle(), 0, VK_WHOLE_SIZE};
5502
5503 VkWriteDescriptorSet descriptor_write = vk_testing::Device::write_descriptor_set(
5504 vk_testing::DescriptorSet(), 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &buffer_info);
5505
5506 // Find address of extension call and make the call
5507 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005508 (PFN_vkCmdPushDescriptorSetKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
unknown088160a2019-05-23 17:43:13 -06005509 ASSERT_TRUE(vkCmdPushDescriptorSetKHR != nullptr);
5510
5511 // Section 1: Queue family matching/capabilities.
5512 // Create command pool on a non-graphics queue
5513 const uint32_t no_gfx_qfi = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT);
5514 const uint32_t transfer_only_qfi =
5515 m_device->QueueFamilyMatching(VK_QUEUE_TRANSFER_BIT, (VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT));
5516 if ((UINT32_MAX == transfer_only_qfi) && (UINT32_MAX == no_gfx_qfi)) {
unknownc3033e52019-06-21 16:56:20 -06005517 printf("%s No compute or transfer only queue family, skipping bindpoint and queue tests.\n", kSkipPrefix);
unknown088160a2019-05-23 17:43:13 -06005518 } else {
5519 const uint32_t err_qfi = (UINT32_MAX == no_gfx_qfi) ? transfer_only_qfi : no_gfx_qfi;
5520
5521 VkCommandPoolObj command_pool(m_device, err_qfi);
5522 ASSERT_TRUE(command_pool.initialized());
5523 VkCommandBufferObj command_buffer(m_device, &command_pool);
5524 ASSERT_TRUE(command_buffer.initialized());
5525 command_buffer.begin();
5526
Mark Lobodzinski20310782020-02-28 14:25:17 -07005527 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363");
5528 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330");
unknown088160a2019-05-23 17:43:13 -06005529 if (err_qfi == transfer_only_qfi) {
5530 // This as this queue neither supports the gfx or compute bindpoints, we'll get two errors
Mark Lobodzinski20310782020-02-28 14:25:17 -07005531 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool");
unknown088160a2019-05-23 17:43:13 -06005532 }
5533 vkCmdPushDescriptorSetKHR(command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
5534 &descriptor_write);
5535 m_errorMonitor->VerifyFound();
5536 command_buffer.end();
5537
5538 // If we succeed in testing only one condition above, we need to test the other below.
5539 if ((UINT32_MAX != transfer_only_qfi) && (err_qfi != transfer_only_qfi)) {
5540 // Need to test the neither compute/gfx supported case separately.
5541 VkCommandPoolObj tran_command_pool(m_device, transfer_only_qfi);
5542 ASSERT_TRUE(tran_command_pool.initialized());
5543 VkCommandBufferObj tran_command_buffer(m_device, &tran_command_pool);
5544 ASSERT_TRUE(tran_command_buffer.initialized());
5545 tran_command_buffer.begin();
5546
5547 // We can't avoid getting *both* errors in this case
Mark Lobodzinski20310782020-02-28 14:25:17 -07005548 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363");
5549 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330");
5550 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool");
unknown088160a2019-05-23 17:43:13 -06005551 vkCmdPushDescriptorSetKHR(tran_command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
5552 &descriptor_write);
5553 m_errorMonitor->VerifyFound();
5554 tran_command_buffer.end();
5555 }
5556 }
5557
5558 // Push to the non-push binding
5559 m_commandBuffer->begin();
Mark Lobodzinski20310782020-02-28 14:25:17 -07005560 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00365");
unknown088160a2019-05-23 17:43:13 -06005561 vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 1, 1,
5562 &descriptor_write);
5563 m_errorMonitor->VerifyFound();
5564
5565 // Specify set out of bounds
Mark Lobodzinski20310782020-02-28 14:25:17 -07005566 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00364");
unknown088160a2019-05-23 17:43:13 -06005567 vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 2, 1,
5568 &descriptor_write);
5569 m_errorMonitor->VerifyFound();
5570 m_commandBuffer->end();
5571
5572 // This is a test for VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording
5573 // TODO: Add VALIDATION_ERROR_ code support to core_validation::ValidateCmd
Mark Lobodzinski20310782020-02-28 14:25:17 -07005574 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung85584a72021-09-30 21:43:38 -07005575 "You must call vkBeginCommandBuffer() before this call to vkCmdPushDescriptorSetKHR");
Mark Lobodzinski20310782020-02-28 14:25:17 -07005576 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330");
unknown088160a2019-05-23 17:43:13 -06005577 vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
5578 &descriptor_write);
5579 m_errorMonitor->VerifyFound();
5580}
5581
Jeremy Hayesf96a5162020-02-10 13:49:31 -07005582TEST_F(VkLayerTest, PushDescriptorSetCmdBufferOffsetUnaligned) {
5583 TEST_DESCRIPTION("Attempt to push a push descriptor set buffer with unaligned offset.");
sjfricked8e01c52022-07-06 14:09:04 +09005584 AddRequiredExtensions(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
Jeremy Hayesf96a5162020-02-10 13:49:31 -07005585
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005586 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sjfricked8e01c52022-07-06 14:09:04 +09005587 if (!AreRequiredExtensionsEnabled()) {
5588 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Jeremy Hayesf96a5162020-02-10 13:49:31 -07005589 }
5590 ASSERT_NO_FATAL_FAILURE(InitState());
5591
5592 auto const push_descriptor_prop = GetPushDescriptorProperties(instance(), gpu());
5593 if (push_descriptor_prop.maxPushDescriptors < 1) {
5594 // Some implementations report an invalid maxPushDescriptors of 0.
5595 printf("%s maxPushDescriptors is zero, skipping test\n", kSkipPrefix);
5596 return;
5597 }
5598
5599 auto const min_alignment = m_device->props.limits.minUniformBufferOffsetAlignment;
5600 if (min_alignment == 0) {
5601 printf("%s minUniformBufferOffsetAlignment is zero, skipping test\n", kSkipPrefix);
5602 return;
5603 }
5604
5605 VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr};
5606 const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
5607 ASSERT_TRUE(push_ds_layout.initialized());
5608
5609 const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout});
5610 ASSERT_TRUE(pipeline_layout.initialized());
5611
5612 const uint32_t buffer_data[4] = {4, 5, 6, 7};
5613 VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
5614 ASSERT_TRUE(buffer_obj.initialized());
5615
5616 // Use an invalid alignment.
5617 VkDescriptorBufferInfo buffer_info = {buffer_obj.handle(), min_alignment - 1, VK_WHOLE_SIZE};
5618 VkWriteDescriptorSet descriptor_write = vk_testing::Device::write_descriptor_set(
5619 vk_testing::DescriptorSet(), 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &buffer_info);
5620
5621 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR =
5622 (PFN_vkCmdPushDescriptorSetKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
5623 ASSERT_TRUE(vkCmdPushDescriptorSetKHR != nullptr);
5624
5625 m_commandBuffer->begin();
Mark Lobodzinski20310782020-02-28 14:25:17 -07005626 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00327");
Jeremy Hayesf96a5162020-02-10 13:49:31 -07005627 vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
5628 &descriptor_write);
5629 m_errorMonitor->VerifyFound();
5630
5631 m_commandBuffer->end();
5632}
5633
unknown088160a2019-05-23 17:43:13 -06005634TEST_F(VkLayerTest, SetDynScissorParamTests) {
5635 TEST_DESCRIPTION("Test parameters of vkCmdSetScissor without multiViewport feature");
5636
5637 VkPhysicalDeviceFeatures features{};
5638 ASSERT_NO_FATAL_FAILURE(Init(&features));
5639
5640 const VkRect2D scissor = {{0, 0}, {16, 16}};
5641 const VkRect2D scissors[] = {scissor, scissor};
5642
5643 m_commandBuffer->begin();
5644
5645 // array tests
Mark Lobodzinski20310782020-02-28 14:25:17 -07005646 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005647 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 1, scissors);
unknown088160a2019-05-23 17:43:13 -06005648 m_errorMonitor->VerifyFound();
5649
Mark Lobodzinski20310782020-02-28 14:25:17 -07005650 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005651 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06005652 m_errorMonitor->VerifyFound();
5653
Mark Lobodzinski20310782020-02-28 14:25:17 -07005654 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005655 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 2, scissors);
unknown088160a2019-05-23 17:43:13 -06005656 m_errorMonitor->VerifyFound();
5657
Mark Lobodzinski20310782020-02-28 14:25:17 -07005658 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593");
5659 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005660 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 2, scissors);
unknown088160a2019-05-23 17:43:13 -06005661 m_errorMonitor->VerifyFound();
5662
Mark Lobodzinski20310782020-02-28 14:25:17 -07005663 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005664 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, nullptr);
unknown088160a2019-05-23 17:43:13 -06005665 m_errorMonitor->VerifyFound();
5666
5667 struct TestCase {
5668 VkRect2D scissor;
5669 std::string vuid;
5670 };
5671
5672 std::vector<TestCase> test_cases = {{{{-1, 0}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"},
5673 {{{0, -1}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"},
5674 {{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
5675 {{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
5676 {{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
5677 {{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetScissor-offset-00597"},
5678 {{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetScissor-offset-00597"},
5679 {{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetScissor-offset-00597"}};
5680
5681 for (const auto &test_case : test_cases) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07005682 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005683 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
unknown088160a2019-05-23 17:43:13 -06005684 m_errorMonitor->VerifyFound();
5685 }
5686
5687 m_commandBuffer->end();
5688}
5689
5690TEST_F(VkLayerTest, SetDynScissorParamMultiviewportTests) {
5691 TEST_DESCRIPTION("Test parameters of vkCmdSetScissor with multiViewport feature enabled");
5692
5693 ASSERT_NO_FATAL_FAILURE(Init());
5694
5695 if (!m_device->phy().features().multiViewport) {
5696 printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix);
5697 return;
5698 }
5699
unknown088160a2019-05-23 17:43:13 -06005700 m_commandBuffer->begin();
5701
Mark Lobodzinski20310782020-02-28 14:25:17 -07005702 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005703 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06005704 m_errorMonitor->VerifyFound();
5705
Petr Kraus14e49492019-09-09 20:13:29 +02005706 const auto max_scissors = m_device->props.limits.maxViewports;
5707
Mark Lobodzinski20310782020-02-28 14:25:17 -07005708 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005709 vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors, nullptr);
unknown088160a2019-05-23 17:43:13 -06005710 m_errorMonitor->VerifyFound();
5711
Petr Kraus14e49492019-09-09 20:13:29 +02005712 const uint32_t too_big_max_scissors = 65536 + 1; // let's say this is too much to allocate
5713 if (max_scissors >= too_big_max_scissors) {
5714 printf("%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping part of test.\n",
5715 kSkipPrefix);
5716 } else {
5717 const VkRect2D scissor = {{0, 0}, {16, 16}};
5718 const std::vector<VkRect2D> scissors(max_scissors + 1, scissor);
5719
Mark Lobodzinski20310782020-02-28 14:25:17 -07005720 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005721 vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors + 1, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005722 m_errorMonitor->VerifyFound();
5723
Mark Lobodzinski20310782020-02-28 14:25:17 -07005724 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005725 vk::CmdSetScissor(m_commandBuffer->handle(), max_scissors, 1, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005726 m_errorMonitor->VerifyFound();
5727
Mark Lobodzinski20310782020-02-28 14:25:17 -07005728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005729 vk::CmdSetScissor(m_commandBuffer->handle(), 1, max_scissors, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005730 m_errorMonitor->VerifyFound();
5731
Mark Lobodzinski20310782020-02-28 14:25:17 -07005732 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005733 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02005734 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06005735 }
unknown088160a2019-05-23 17:43:13 -06005736}
5737
Tony-LunarG667cc022021-06-25 10:11:17 -06005738TEST_F(VkLayerTest, MultiDrawTests) {
5739 TEST_DESCRIPTION("Test validation of multi_draw extension");
5740 SetTargetApiVersion(VK_API_VERSION_1_2);
5741 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
5742 if (DeviceValidationVersion() < VK_API_VERSION_1_2) {
sjfrickebdd58dd2022-05-20 14:22:50 +09005743 GTEST_SKIP() << "At least Vulkan version 1.2 is required";
Tony-LunarG667cc022021-06-25 10:11:17 -06005744 }
5745
5746 auto multi_draw_features = LvlInitStruct<VkPhysicalDeviceMultiDrawFeaturesEXT>();
5747 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&multi_draw_features);
5748 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
5749 if (!multi_draw_features.multiDraw) {
5750 printf("%s Test requires (unsupported) multiDraw, skipping\n", kSkipPrefix);
5751 return;
5752 }
5753 if (DeviceExtensionSupported(gpu(), nullptr, VK_EXT_MULTI_DRAW_EXTENSION_NAME)) {
5754 m_device_extension_names.push_back(VK_EXT_MULTI_DRAW_EXTENSION_NAME);
5755 } else {
5756 printf("%s VK_EXT_multi_draw extension not supported, skipping test\n", kSkipPrefix);
5757 return;
5758 }
5759 auto multi_draw_properties = LvlInitStruct<VkPhysicalDeviceMultiDrawPropertiesEXT>();
5760 auto properties2 = LvlInitStruct<VkPhysicalDeviceProperties2>(&multi_draw_properties);
5761 vk::GetPhysicalDeviceProperties2(gpu(), &properties2);
5762
5763 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
5764 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5765
5766 auto vkCmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawMultiEXT");
5767 auto vkCmdDrawMultiIndexedEXT =
5768 (PFN_vkCmdDrawMultiIndexedEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawMultiIndexedEXT");
5769 assert(vkCmdDrawMultiEXT != nullptr && vkCmdDrawMultiIndexedEXT != nullptr);
5770
5771 VkMultiDrawInfoEXT multi_draws[3] = {};
5772 multi_draws[0].vertexCount = multi_draws[1].vertexCount = multi_draws[2].vertexCount = 3;
5773
5774 VkMultiDrawIndexedInfoEXT multi_draw_indices[3] = {};
5775 multi_draw_indices[0].indexCount = multi_draw_indices[1].indexCount = multi_draw_indices[2].indexCount = 1;
5776
5777 CreatePipelineHelper pipe(*this);
5778 pipe.InitInfo();
5779 pipe.InitState();
5780 pipe.CreateGraphicsPipeline();
5781
5782 // Try existing VUID checks
5783 m_commandBuffer->begin();
5784 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
5785
5786 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
5787 &pipe.descriptor_set_->set_, 0, NULL);
5788 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiEXT-None-02700");
5789 vkCmdDrawMultiEXT(m_commandBuffer->handle(), 3, multi_draws, 1, 0, sizeof(VkMultiDrawInfoEXT));
5790 m_errorMonitor->VerifyFound();
5791 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-None-02700");
5792 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), 3, multi_draw_indices, 1, 0, sizeof(VkMultiDrawIndexedInfoEXT), 0);
5793 m_errorMonitor->VerifyFound();
5794
5795 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
5796
5797 // New VUIDs added with multi_draw (also see GPU-AV)
5798 VkBufferObj buffer;
5799 buffer.init(*m_device, 1024, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
5800 multi_draw_indices[2].indexCount = 513;
5801 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-firstIndex-04938");
5802 m_commandBuffer->BindIndexBuffer(&buffer, 0, VK_INDEX_TYPE_UINT16);
5803 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), 3, multi_draw_indices, 1, 0, sizeof(VkMultiDrawIndexedInfoEXT), 0);
5804 m_errorMonitor->VerifyFound();
5805 multi_draw_indices[2].indexCount = 1;
5806
5807 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiEXT-stride-04936");
5808 vkCmdDrawMultiEXT(m_commandBuffer->handle(), 3, multi_draws, 1, 0, sizeof(VkMultiDrawInfoEXT) + 1);
5809 m_errorMonitor->VerifyFound();
5810 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-stride-04941");
5811 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), 3, multi_draw_indices, 1, 0, sizeof(VkMultiDrawIndexedInfoEXT) + 1, 0);
5812 m_errorMonitor->VerifyFound();
5813
5814 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiEXT-drawCount-04935");
5815 vkCmdDrawMultiEXT(m_commandBuffer->handle(), 3, nullptr, 1, 0, sizeof(VkMultiDrawInfoEXT));
5816 m_errorMonitor->VerifyFound();
5817 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-drawCount-04940");
5818 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), 3, nullptr, 1, 0, sizeof(VkMultiDrawIndexedInfoEXT), 0);
5819 m_errorMonitor->VerifyFound();
5820
5821 if (multi_draw_properties.maxMultiDrawCount < UINT32_MAX) {
5822 uint32_t draw_count = multi_draw_properties.maxMultiDrawCount + 1;
5823 std::vector<VkMultiDrawInfoEXT> max_multi_draws(draw_count);
5824 std::vector<VkMultiDrawIndexedInfoEXT> max_multi_indexed_draws(draw_count);
5825 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiEXT-drawCount-04934");
5826 vkCmdDrawMultiEXT(m_commandBuffer->handle(), draw_count, max_multi_draws.data(), 1, 0, sizeof(VkMultiDrawInfoEXT));
5827 m_errorMonitor->VerifyFound();
5828 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-drawCount-04939");
5829 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), draw_count, max_multi_indexed_draws.data(), 1, 0,
5830 sizeof(VkMultiDrawIndexedInfoEXT), 0);
5831 m_errorMonitor->VerifyFound();
5832 }
5833}
5834
5835TEST_F(VkLayerTest, MultiDrawFeatures) {
5836 TEST_DESCRIPTION("Test validation of multi draw feature enabled");
5837 SetTargetApiVersion(VK_API_VERSION_1_2);
5838 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
5839 if (DeviceValidationVersion() < VK_API_VERSION_1_2) {
sjfrickebdd58dd2022-05-20 14:22:50 +09005840 GTEST_SKIP() << "At least Vulkan version 1.2 is required";
Tony-LunarG667cc022021-06-25 10:11:17 -06005841 }
5842 if (DeviceExtensionSupported(gpu(), nullptr, VK_EXT_MULTI_DRAW_EXTENSION_NAME)) {
5843 m_device_extension_names.push_back(VK_EXT_MULTI_DRAW_EXTENSION_NAME);
5844 } else {
5845 printf("%s VK_EXT_multi_draw extension not supported, skipping test\n", kSkipPrefix);
5846 return;
5847 }
5848 ASSERT_NO_FATAL_FAILURE(InitState());
5849 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5850
sfricke-samsungca162082022-02-10 08:53:41 -08005851 auto multi_draw_props = LvlInitStruct<VkPhysicalDeviceMultiDrawPropertiesEXT>();
5852 auto pd_props2 = LvlInitStruct<VkPhysicalDeviceProperties2>(&multi_draw_props);
5853 vk::GetPhysicalDeviceProperties2(gpu(), &pd_props2);
5854 if (multi_draw_props.maxMultiDrawCount == 0) {
5855 // If using MockICD and devsim the value might be zero'ed and cause false errors
5856 return;
5857 }
5858
Tony-LunarG667cc022021-06-25 10:11:17 -06005859 auto vkCmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawMultiEXT");
5860 auto vkCmdDrawMultiIndexedEXT =
5861 (PFN_vkCmdDrawMultiIndexedEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawMultiIndexedEXT");
5862 assert(vkCmdDrawMultiEXT != nullptr && vkCmdDrawMultiIndexedEXT != nullptr);
5863
5864 VkMultiDrawInfoEXT multi_draws[3] = {};
5865 multi_draws[0].vertexCount = multi_draws[1].vertexCount = multi_draws[2].vertexCount = 3;
5866
5867 VkMultiDrawIndexedInfoEXT multi_draw_indices[3] = {};
5868 multi_draw_indices[0].indexCount = multi_draw_indices[1].indexCount = multi_draw_indices[2].indexCount = 1;
5869
5870 CreatePipelineHelper pipe(*this);
5871 pipe.InitInfo();
5872 pipe.InitState();
5873 pipe.CreateGraphicsPipeline();
5874
5875 m_commandBuffer->begin();
5876 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
5877 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
5878 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiEXT-None-04933");
5879 vkCmdDrawMultiEXT(m_commandBuffer->handle(), 3, multi_draws, 1, 0, sizeof(VkMultiDrawInfoEXT));
5880 m_errorMonitor->VerifyFound();
5881 VkBufferObj buffer;
5882 buffer.init(*m_device, 1024, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
5883 m_commandBuffer->BindIndexBuffer(&buffer, 0, VK_INDEX_TYPE_UINT16);
5884 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMultiIndexedEXT-None-04937");
5885 vkCmdDrawMultiIndexedEXT(m_commandBuffer->handle(), 3, multi_draw_indices, 1, 0, sizeof(VkMultiDrawIndexedInfoEXT), 0);
5886 m_errorMonitor->VerifyFound();
5887}
5888
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005889TEST_F(VkLayerTest, IndirectDrawTests) {
5890 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirect and vkCmdDrawIndexedIndirect");
unknown088160a2019-05-23 17:43:13 -06005891
sjfricked8e01c52022-07-06 14:09:04 +09005892 AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005893 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
5894
5895 if (IsPlatform(kMockICD) || DeviceSimulation()) {
sjfricke11b24692022-06-21 20:49:53 +09005896 GTEST_SKIP() << "Test not supported by MockICD";
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005897 }
sjfricked8e01c52022-07-06 14:09:04 +09005898 if (!AreRequiredExtensionsEnabled()) {
5899 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
5900 }
Aaron Hagand1a61212021-12-22 11:53:49 -05005901 ASSERT_NO_FATAL_FAILURE(InitState());
unknown088160a2019-05-23 17:43:13 -06005902 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5903
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005904 CreatePipelineHelper pipe(*this);
5905 pipe.InitInfo();
5906 const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
sfricke-samsung1c61f192021-12-31 01:53:03 -06005907 VkPipelineDynamicStateCreateInfo dyn_state_ci = LvlInitStruct<VkPipelineDynamicStateCreateInfo>();
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005908 dyn_state_ci.dynamicStateCount = size(dyn_states);
5909 dyn_state_ci.pDynamicStates = dyn_states;
5910 pipe.dyn_state_ci_ = dyn_state_ci;
5911 pipe.InitState();
5912 pipe.CreateGraphicsPipeline();
unknown088160a2019-05-23 17:43:13 -06005913
5914 m_commandBuffer->begin();
5915 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
5916
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005917 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
5918 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
5919 &pipe.descriptor_set_->set_, 0, NULL);
unknown088160a2019-05-23 17:43:13 -06005920
5921 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005922 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06005923 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005924 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06005925
sfricke-samsung1c61f192021-12-31 01:53:03 -06005926 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06005927 buffer_create_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
5928 buffer_create_info.size = sizeof(VkDrawIndirectCommand);
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005929 VkBufferObj draw_buffer;
5930 draw_buffer.init(*m_device, buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06005931
Aaron Hagand1a61212021-12-22 11:53:49 -05005932 VkBufferObj draw_buffer_correct;
5933 buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
5934 draw_buffer_correct.init(*m_device, buffer_create_info);
5935
unknown088160a2019-05-23 17:43:13 -06005936 // VUID-vkCmdDrawIndirect-buffer-02709
Mark Lobodzinski20310782020-02-28 14:25:17 -07005937 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirect-buffer-02709");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005938 vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06005939 m_errorMonitor->VerifyFound();
5940
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005941 // VUID-vkCmdDrawIndirect-drawCount-02718
Aaron Hagand1a61212021-12-22 11:53:49 -05005942 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirect-drawCount-00488");
5943 vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_buffer_correct.handle(), 0, 2, sizeof(VkDrawIndirectCommand));
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005944 m_errorMonitor->VerifyFound();
5945
Aaron Hagand1a61212021-12-22 11:53:49 -05005946 // VUID-vkCmdDrawIndexedIndirect-commandBuffer-02701
5947 // VUID-vkCmdDrawIndexedIndirect-drawCount-00540
5948 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02701");
5949 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirect-drawCount-00540");
5950 vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), draw_buffer_correct.handle(), 0, 2, sizeof(VkDrawIndexedIndirectCommand));
Mark Lobodzinski128608f2020-11-02 13:46:57 -07005951 m_errorMonitor->VerifyFound();
5952
unknown088160a2019-05-23 17:43:13 -06005953 m_commandBuffer->EndRenderPass();
5954 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06005955}
5956
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005957TEST_F(VkLayerTest, DrawIndirectByteCountEXT) {
5958 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectByteCountEXT");
5959
sjfricked8e01c52022-07-06 14:09:04 +09005960 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
5961
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005962 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005963
sjfricked8e01c52022-07-06 14:09:04 +09005964 if (!AreRequiredExtensionsEnabled()) {
5965 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005966 }
5967
5968 ASSERT_NO_FATAL_FAILURE(InitState());
5969 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
5970
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07005971 auto tf_properties = LvlInitStruct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
5972 auto pd_properties = LvlInitStruct<VkPhysicalDeviceProperties2>(&tf_properties);
sfricke-samsungd5e9adb2020-10-26 03:59:29 -07005973 vk::GetPhysicalDeviceProperties2(gpu(), &pd_properties);
5974
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005975 PFN_vkCmdDrawIndirectByteCountEXT fpvkCmdDrawIndirectByteCountEXT =
5976 (PFN_vkCmdDrawIndirectByteCountEXT)vk::GetDeviceProcAddr(device(), "vkCmdDrawIndirectByteCountEXT");
5977
5978 m_commandBuffer->begin();
5979 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
sfricke-samsung1c61f192021-12-31 01:53:03 -06005980 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005981 buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
5982 buffer_create_info.size = 1024;
5983 VkBufferObj counter_buffer;
5984 counter_buffer.init(*m_device, buffer_create_info);
5985
sfricke-samsungd5e9adb2020-10-26 03:59:29 -07005986 // Greater stride than maxTransformFeedbackBufferDataStride
Mark Lobodzinski20310782020-02-28 14:25:17 -07005987 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289");
sfricke-samsungd5e9adb2020-10-26 03:59:29 -07005988 fpvkCmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 0, 0xCADECADE);
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005989 m_errorMonitor->VerifyFound();
5990
sfricke-samsungd5e9adb2020-10-26 03:59:29 -07005991 // some mock ICD json files are missing a valid stride value
5992 if (tf_properties.maxTransformFeedbackBufferDataStride > 0) {
5993 // non-4 multiple stride
sfricke-samsung6886c4b2021-01-16 08:37:35 -08005994 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-counterBufferOffset-04568");
sfricke-samsungd5e9adb2020-10-26 03:59:29 -07005995 fpvkCmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 1, 4);
5996 m_errorMonitor->VerifyFound();
5997 }
5998
Mark Lobodzinski977f0342019-12-19 14:24:09 -07005999 m_commandBuffer->EndRenderPass();
6000 m_commandBuffer->end();
Tony-LunarG983bbc52020-11-06 11:04:59 -07006001
6002 if (!tf_properties.maxTransformFeedbackBufferDataStride) {
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006003 GTEST_SKIP() << "maxTransformFeedbackBufferDataStride is zero, skipping subtests";
Tony-LunarG983bbc52020-11-06 11:04:59 -07006004 }
6005
6006 std::vector<const char *> device_extension_names;
6007 device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
6008 VkDeviceObj test_device(0, gpu(), device_extension_names);
6009 VkCommandPoolObj commandPool(&test_device, 0);
6010 VkCommandBufferObj commandBuffer(&test_device, &commandPool);
6011 VkBufferObj counter_buffer2;
6012 counter_buffer2.init(test_device, buffer_create_info);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006013
Tony-LunarG983bbc52020-11-06 11:04:59 -07006014 VkPipelineLayoutObj pipelineLayout(&test_device);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006015
sfricke-samsung1c61f192021-12-31 01:53:03 -06006016 VkRenderPassCreateInfo rp_info = LvlInitStruct<VkRenderPassCreateInfo>();
Tony-LunarG983bbc52020-11-06 11:04:59 -07006017 VkSubpassDescription subpass = {};
Tony-LunarG983bbc52020-11-06 11:04:59 -07006018 rp_info.pSubpasses = &subpass;
6019 rp_info.subpassCount = 1;
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006020 vk_testing::RenderPass renderpass(test_device, rp_info);
6021 ASSERT_TRUE(renderpass.handle());
6022
Tony-LunarG983bbc52020-11-06 11:04:59 -07006023 VkPipelineObj pipeline(&test_device);
sfricke-samsungae54c1e2022-01-21 05:35:21 -08006024 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, SPV_ENV_VULKAN_1_0, SPV_SOURCE_GLSL_TRY);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006025 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, SPV_ENV_VULKAN_1_0, SPV_SOURCE_GLSL_TRY);
sjfricke394227a2022-06-20 16:47:38 +09006026 vs.InitFromGLSLTry(false, &test_device);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006027 fs.InitFromGLSLTry(false, &test_device);
Tony-LunarG983bbc52020-11-06 11:04:59 -07006028 pipeline.AddShader(&vs);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006029 pipeline.AddShader(&fs);
6030 pipeline.CreateVKPipeline(pipelineLayout.handle(), renderpass.handle());
6031 m_renderPassBeginInfo.renderPass = renderpass.handle();
6032 VkFramebufferCreateInfo fbci = {
6033 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, renderpass.handle(), 0, nullptr, 256, 256, 1};
6034 vk_testing::Framebuffer fb(test_device, fbci);
6035 ASSERT_TRUE(fb.initialized());
6036 m_renderPassBeginInfo.framebuffer = fb.handle();
6037 m_renderPassBeginInfo.renderPass = renderpass.handle();
Tony-LunarG983bbc52020-11-06 11:04:59 -07006038 commandBuffer.begin();
6039 VkViewport viewport = {0, 0, 16, 16, 0, 1};
6040 vk::CmdSetViewport(commandBuffer.handle(), 0, 1, &viewport);
6041 VkRect2D scissor = {{0, 0}, {16, 16}};
6042 vk::CmdSetScissor(commandBuffer.handle(), 0, 1, &scissor);
6043 vk::CmdBindPipeline(commandBuffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle());
6044 commandBuffer.BeginRenderPass(m_renderPassBeginInfo);
6045 if (!tf_properties.transformFeedbackDraw) {
sfricke-samsungba459bd2020-12-06 23:20:04 -08006046 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-transformFeedbackDraw-02288");
Tony-LunarG983bbc52020-11-06 11:04:59 -07006047 }
6048 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-transformFeedback-02287");
6049 fpvkCmdDrawIndirectByteCountEXT(commandBuffer.handle(), 1, 0, counter_buffer2.handle(), 0, 0, 1);
6050 m_errorMonitor->VerifyFound();
Mark Lobodzinski977f0342019-12-19 14:24:09 -07006051}
6052
unknown088160a2019-05-23 17:43:13 -06006053TEST_F(VkLayerTest, DrawIndirectCountKHR) {
6054 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectCountKHR");
6055
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006056 AddRequiredExtensions(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
6057 ASSERT_NO_FATAL_FAILURE(InitFramework());
6058 if (!AreRequiredExtensionsEnabled()) {
6059 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
unknown088160a2019-05-23 17:43:13 -06006060 }
6061 ASSERT_NO_FATAL_FAILURE(InitState());
6062 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6063
unknown088160a2019-05-23 17:43:13 -06006064 auto vkCmdDrawIndirectCountKHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006065 (PFN_vkCmdDrawIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndirectCountKHR");
unknown088160a2019-05-23 17:43:13 -06006066
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006067 CreatePipelineHelper pipe(*this);
6068 pipe.InitInfo();
6069 const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
sfricke-samsung1c61f192021-12-31 01:53:03 -06006070 VkPipelineDynamicStateCreateInfo dyn_state_ci = LvlInitStruct<VkPipelineDynamicStateCreateInfo>();
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006071 dyn_state_ci.dynamicStateCount = size(dyn_states);
6072 dyn_state_ci.pDynamicStates = dyn_states;
6073 pipe.dyn_state_ci_ = dyn_state_ci;
6074 pipe.InitState();
6075 pipe.CreateGraphicsPipeline();
unknown088160a2019-05-23 17:43:13 -06006076
6077 m_commandBuffer->begin();
6078 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
6079
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006080 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
6081 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
6082 &pipe.descriptor_set_->set_, 0, NULL);
unknown088160a2019-05-23 17:43:13 -06006083
6084 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006085 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06006086 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006087 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06006088
sfricke-samsung1c61f192021-12-31 01:53:03 -06006089 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06006090 buffer_create_info.size = sizeof(VkDrawIndirectCommand);
6091 buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006092 vk_testing::Buffer draw_buffer;
6093 draw_buffer.init_no_mem(*m_device, buffer_create_info);
6094 ASSERT_TRUE(draw_buffer.initialized());
unknown088160a2019-05-23 17:43:13 -06006095
sjfrickeedd669c2022-06-02 17:37:19 +09006096 VkDeviceSize count_buffer_size = 128;
sfricke-samsung1c61f192021-12-31 01:53:03 -06006097 VkBufferCreateInfo count_buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
sjfrickeedd669c2022-06-02 17:37:19 +09006098 count_buffer_create_info.size = count_buffer_size;
unknown088160a2019-05-23 17:43:13 -06006099 count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006100 VkBufferObj count_buffer;
6101 count_buffer.init(*m_device, count_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06006102
Mark Lobodzinski20310782020-02-28 14:25:17 -07006103 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-buffer-02708");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006104 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1,
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006105 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06006106 m_errorMonitor->VerifyFound();
6107
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006108 draw_buffer.bind_memory(*m_device, 0, 0);
unknown088160a2019-05-23 17:43:13 -06006109
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006110 vk_testing::Buffer count_buffer_unbound;
6111 count_buffer_unbound.init_no_mem(*m_device, count_buffer_create_info);
6112 ASSERT_TRUE(count_buffer_unbound.initialized());
unknown088160a2019-05-23 17:43:13 -06006113
sjfrickeedd669c2022-06-02 17:37:19 +09006114 VkBufferObj count_buffer_wrong;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006115 count_buffer_create_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
sjfrickeedd669c2022-06-02 17:37:19 +09006116 count_buffer_wrong.init(*m_device, count_buffer_create_info);
6117
Mark Lobodzinski20310782020-02-28 14:25:17 -07006118 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBuffer-02714");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006119 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_unbound.handle(), 0, 1,
6120 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06006121 m_errorMonitor->VerifyFound();
6122
sjfrickeedd669c2022-06-02 17:37:19 +09006123 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, " VUID-vkCmdDrawIndirectCount-countBuffer-02715");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006124 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_wrong.handle(), 0, 1,
sjfrickeedd669c2022-06-02 17:37:19 +09006125 sizeof(VkDrawIndirectCommand));
6126 m_errorMonitor->VerifyFound();
6127
Mark Lobodzinski20310782020-02-28 14:25:17 -07006128 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-offset-02710");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006129 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 1, count_buffer.handle(), 0, 1,
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006130 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06006131 m_errorMonitor->VerifyFound();
6132
Mark Lobodzinski20310782020-02-28 14:25:17 -07006133 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBufferOffset-02716");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006134 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 1, 1,
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006135 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06006136 m_errorMonitor->VerifyFound();
6137
sjfrickeedd669c2022-06-02 17:37:19 +09006138 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBufferOffset-04129");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006139 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), count_buffer_size, 1,
sjfrickeedd669c2022-06-02 17:37:19 +09006140 sizeof(VkDrawIndirectCommand));
6141 m_errorMonitor->VerifyFound();
6142
Mark Lobodzinski20310782020-02-28 14:25:17 -07006143 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-stride-03110");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006144 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, 1);
unknown088160a2019-05-23 17:43:13 -06006145 m_errorMonitor->VerifyFound();
6146
unknown088160a2019-05-23 17:43:13 -06006147 m_commandBuffer->EndRenderPass();
6148 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06006149}
6150
6151TEST_F(VkLayerTest, DrawIndexedIndirectCountKHR) {
6152 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndexedIndirectCountKHR");
6153
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006154 AddRequiredExtensions(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07006155 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006156 if (!AreRequiredExtensionsEnabled()) {
6157 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
unknown088160a2019-05-23 17:43:13 -06006158 }
6159 ASSERT_NO_FATAL_FAILURE(InitState());
6160 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6161
unknown088160a2019-05-23 17:43:13 -06006162 auto vkCmdDrawIndexedIndirectCountKHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006163 (PFN_vkCmdDrawIndexedIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndexedIndirectCountKHR");
unknown088160a2019-05-23 17:43:13 -06006164
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006165 CreatePipelineHelper pipe(*this);
6166 pipe.InitInfo();
6167 const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
sfricke-samsung1c61f192021-12-31 01:53:03 -06006168 VkPipelineDynamicStateCreateInfo dyn_state_ci = LvlInitStruct<VkPipelineDynamicStateCreateInfo>();
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006169 dyn_state_ci.dynamicStateCount = size(dyn_states);
6170 dyn_state_ci.pDynamicStates = dyn_states;
6171 pipe.dyn_state_ci_ = dyn_state_ci;
6172 pipe.InitState();
6173 pipe.CreateGraphicsPipeline();
unknown088160a2019-05-23 17:43:13 -06006174
6175 m_commandBuffer->begin();
6176 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
6177
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006178 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
6179 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
6180 &pipe.descriptor_set_->set_, 0, NULL);
unknown088160a2019-05-23 17:43:13 -06006181
6182 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006183 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06006184 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006185 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06006186
sfricke-samsung1c61f192021-12-31 01:53:03 -06006187 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06006188 buffer_create_info.size = sizeof(VkDrawIndexedIndirectCommand);
6189 buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006190 VkBufferObj draw_buffer;
6191 draw_buffer.init(*m_device, buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06006192
sjfrickeedd669c2022-06-02 17:37:19 +09006193 VkDeviceSize count_buffer_size = 128;
sfricke-samsung1c61f192021-12-31 01:53:03 -06006194 VkBufferCreateInfo count_buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
sjfrickeedd669c2022-06-02 17:37:19 +09006195 count_buffer_create_info.size = count_buffer_size;
unknown088160a2019-05-23 17:43:13 -06006196 count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006197 VkBufferObj count_buffer;
6198 count_buffer.init(*m_device, count_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06006199
sfricke-samsung1c61f192021-12-31 01:53:03 -06006200 VkBufferCreateInfo index_buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06006201 index_buffer_create_info.size = sizeof(uint32_t);
6202 index_buffer_create_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006203 VkBufferObj index_buffer;
6204 index_buffer.init(*m_device, index_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06006205
Mark Lobodzinski20310782020-02-28 14:25:17 -07006206 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006207 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06006208 sizeof(VkDrawIndexedIndirectCommand));
6209 m_errorMonitor->VerifyFound();
6210
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006211 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
unknown088160a2019-05-23 17:43:13 -06006212
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006213 vk_testing::Buffer draw_buffer_unbound;
6214 draw_buffer_unbound.init_no_mem(*m_device, count_buffer_create_info);
6215 ASSERT_TRUE(draw_buffer_unbound.initialized());
unknown088160a2019-05-23 17:43:13 -06006216
Mark Lobodzinski20310782020-02-28 14:25:17 -07006217 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-buffer-02708");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006218 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer_unbound.handle(), 0, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06006219 sizeof(VkDrawIndexedIndirectCommand));
6220 m_errorMonitor->VerifyFound();
6221
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006222 vk_testing::Buffer count_buffer_unbound;
6223 count_buffer_unbound.init_no_mem(*m_device, count_buffer_create_info);
6224 ASSERT_TRUE(count_buffer_unbound.initialized());
unknown088160a2019-05-23 17:43:13 -06006225
sjfrickeedd669c2022-06-02 17:37:19 +09006226 VkBufferObj count_buffer_wrong;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006227 count_buffer_create_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
sjfrickeedd669c2022-06-02 17:37:19 +09006228 count_buffer_wrong.init(*m_device, count_buffer_create_info);
6229
Mark Lobodzinski20310782020-02-28 14:25:17 -07006230 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006231 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_unbound.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06006232 sizeof(VkDrawIndexedIndirectCommand));
6233 m_errorMonitor->VerifyFound();
6234
sjfrickeedd669c2022-06-02 17:37:19 +09006235 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02715");
6236 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_wrong.handle(), 0, 1,
6237 sizeof(VkDrawIndexedIndirectCommand));
6238 m_errorMonitor->VerifyFound();
6239
Mark Lobodzinski20310782020-02-28 14:25:17 -07006240 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-offset-02710");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006241 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 1, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06006242 sizeof(VkDrawIndexedIndirectCommand));
6243 m_errorMonitor->VerifyFound();
6244
Mark Lobodzinski20310782020-02-28 14:25:17 -07006245 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006246 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 1, 1,
unknown088160a2019-05-23 17:43:13 -06006247 sizeof(VkDrawIndexedIndirectCommand));
6248 m_errorMonitor->VerifyFound();
6249
sjfrickeedd669c2022-06-02 17:37:19 +09006250 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-04129");
6251 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), count_buffer_size,
6252 1, sizeof(VkDrawIndexedIndirectCommand));
6253 m_errorMonitor->VerifyFound();
6254
Mark Lobodzinski20310782020-02-28 14:25:17 -07006255 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-stride-03142");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06006256 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, 1);
unknown088160a2019-05-23 17:43:13 -06006257 m_errorMonitor->VerifyFound();
6258
unknown088160a2019-05-23 17:43:13 -06006259 m_commandBuffer->EndRenderPass();
6260 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06006261}
6262
sfricke-samsung860d3b22020-05-04 21:08:29 -07006263TEST_F(VkLayerTest, DrawIndirectCountFeature) {
6264 TEST_DESCRIPTION("Test covered valid usage for the 1.2 drawIndirectCount feature");
6265
6266 SetTargetApiVersion(VK_API_VERSION_1_2);
6267 ASSERT_NO_FATAL_FAILURE(Init());
6268 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6269 if (DeviceValidationVersion() < VK_API_VERSION_1_2) {
sjfrickebdd58dd2022-05-20 14:22:50 +09006270 GTEST_SKIP() << "At least Vulkan version 1.2 is required";
sfricke-samsung860d3b22020-05-04 21:08:29 -07006271 }
6272
6273 VkBufferObj indirect_buffer;
6274 indirect_buffer.init(*m_device, sizeof(VkDrawIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
6275 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);
6276
6277 VkBufferObj indexed_indirect_buffer;
6278 indexed_indirect_buffer.init(*m_device, sizeof(VkDrawIndexedIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
6279 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);
6280
6281 VkBufferObj count_buffer;
6282 count_buffer.init(*m_device, sizeof(uint32_t), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);
6283
6284 VkBufferObj index_buffer;
6285 index_buffer.init(*m_device, sizeof(uint32_t), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
6286
6287 CreatePipelineHelper pipe(*this);
6288 pipe.InitInfo();
6289 pipe.InitState();
6290 pipe.CreateGraphicsPipeline();
6291
6292 // Make calls to valid commands but without the drawIndirectCount feature set
6293 m_commandBuffer->begin();
6294 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
6295
6296 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
6297
Shannon McPherson2c793ba2020-08-28 12:13:24 -06006298 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-None-04445");
sfricke-samsung860d3b22020-05-04 21:08:29 -07006299 vk::CmdDrawIndirectCount(m_commandBuffer->handle(), indirect_buffer.handle(), 0, count_buffer.handle(), 0, 1,
6300 sizeof(VkDrawIndirectCommand));
6301 m_errorMonitor->VerifyFound();
6302
6303 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
6304
Shannon McPherson2c793ba2020-08-28 12:13:24 -06006305 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-None-04445");
sfricke-samsung860d3b22020-05-04 21:08:29 -07006306 vk::CmdDrawIndexedIndirectCount(m_commandBuffer->handle(), indexed_indirect_buffer.handle(), 0, count_buffer.handle(), 0, 1,
6307 sizeof(VkDrawIndexedIndirectCommand));
6308 m_errorMonitor->VerifyFound();
6309
6310 m_commandBuffer->EndRenderPass();
6311 m_commandBuffer->end();
6312}
6313
unknown088160a2019-05-23 17:43:13 -06006314TEST_F(VkLayerTest, ExclusiveScissorNV) {
6315 TEST_DESCRIPTION("Test VK_NV_scissor_exclusive with multiViewport disabled.");
6316
6317 if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
6318 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
6319 } else {
6320 printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
6321 VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
6322 return;
6323 }
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07006324 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06006325 std::array<const char *, 1> required_device_extensions = {{VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME}};
6326 for (auto device_extension : required_device_extensions) {
6327 if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
6328 m_device_extension_names.push_back(device_extension);
6329 } else {
6330 printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
6331 return;
6332 }
6333 }
6334
6335 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006336 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
unknown088160a2019-05-23 17:43:13 -06006337 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
6338
6339 // Create a device that enables exclusive scissor but disables multiViewport
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07006340 auto exclusive_scissor_features = LvlInitStruct<VkPhysicalDeviceExclusiveScissorFeaturesNV>();
6341 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&exclusive_scissor_features);
unknown088160a2019-05-23 17:43:13 -06006342 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
6343
6344 features2.features.multiViewport = VK_FALSE;
6345
6346 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
6347 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6348
6349 if (m_device->phy().properties().limits.maxViewports) {
6350 printf("%s Device doesn't support the necessary number of viewports, skipping test.\n", kSkipPrefix);
6351 return;
6352 }
6353
6354 // Based on PSOViewportStateTests
6355 {
6356 VkViewport viewport = {0.0f, 0.0f, 64.0f, 64.0f, 0.0f, 1.0f};
6357 VkViewport viewports[] = {viewport, viewport};
6358 VkRect2D scissor = {{0, 0}, {64, 64}};
6359 VkRect2D scissors[100] = {scissor, scissor};
6360
6361 using std::vector;
6362 struct TestCase {
6363 uint32_t viewport_count;
6364 VkViewport *viewports;
6365 uint32_t scissor_count;
6366 VkRect2D *scissors;
6367 uint32_t exclusive_scissor_count;
6368 VkRect2D *exclusive_scissors;
6369
6370 vector<std::string> vuids;
6371 };
6372
6373 vector<TestCase> test_cases = {
6374 {1,
6375 viewports,
6376 1,
6377 scissors,
6378 2,
6379 scissors,
6380 {"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
6381 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}},
6382 {1,
6383 viewports,
6384 1,
6385 scissors,
6386 100,
6387 scissors,
6388 {"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
6389 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028",
6390 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}},
Shannon McPherson24c13d12020-06-18 15:51:41 -06006391 {1, viewports, 1, scissors, 1, nullptr, {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04056"}},
unknown088160a2019-05-23 17:43:13 -06006392 };
6393
6394 for (const auto &test_case : test_cases) {
sfricke-samsung1c61f192021-12-31 01:53:03 -06006395 VkPipelineViewportExclusiveScissorStateCreateInfoNV exc =
6396 LvlInitStruct<VkPipelineViewportExclusiveScissorStateCreateInfoNV>();
unknown088160a2019-05-23 17:43:13 -06006397
6398 const auto break_vp = [&test_case, &exc](CreatePipelineHelper &helper) {
6399 helper.vp_state_ci_.viewportCount = test_case.viewport_count;
6400 helper.vp_state_ci_.pViewports = test_case.viewports;
6401 helper.vp_state_ci_.scissorCount = test_case.scissor_count;
6402 helper.vp_state_ci_.pScissors = test_case.scissors;
6403 helper.vp_state_ci_.pNext = &exc;
6404
6405 exc.exclusiveScissorCount = test_case.exclusive_scissor_count;
6406 exc.pExclusiveScissors = test_case.exclusive_scissors;
6407 };
Mark Lobodzinski20310782020-02-28 14:25:17 -07006408 CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit, test_case.vuids);
unknown088160a2019-05-23 17:43:13 -06006409 }
6410 }
6411
6412 // Based on SetDynScissorParamTests
6413 {
6414 auto vkCmdSetExclusiveScissorNV =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006415 (PFN_vkCmdSetExclusiveScissorNV)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetExclusiveScissorNV");
unknown088160a2019-05-23 17:43:13 -06006416
6417 const VkRect2D scissor = {{0, 0}, {16, 16}};
6418 const VkRect2D scissors[] = {scissor, scissor};
6419
6420 m_commandBuffer->begin();
6421
Mark Lobodzinski20310782020-02-28 14:25:17 -07006422 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
unknown088160a2019-05-23 17:43:13 -06006423 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 1, scissors);
6424 m_errorMonitor->VerifyFound();
6425
Mark Lobodzinski20310782020-02-28 14:25:17 -07006426 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06006427 "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
6428 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 0, nullptr);
6429 m_errorMonitor->VerifyFound();
6430
Mark Lobodzinski20310782020-02-28 14:25:17 -07006431 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
unknown088160a2019-05-23 17:43:13 -06006432 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 2, scissors);
6433 m_errorMonitor->VerifyFound();
6434
Mark Lobodzinski20310782020-02-28 14:25:17 -07006435 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06006436 "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
Mark Lobodzinski20310782020-02-28 14:25:17 -07006437 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
unknown088160a2019-05-23 17:43:13 -06006438 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 0, scissors);
6439 m_errorMonitor->VerifyFound();
6440
Mark Lobodzinski20310782020-02-28 14:25:17 -07006441 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
6442 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
unknown088160a2019-05-23 17:43:13 -06006443 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 2, scissors);
6444 m_errorMonitor->VerifyFound();
6445
Mark Lobodzinski20310782020-02-28 14:25:17 -07006446 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06006447 "vkCmdSetExclusiveScissorNV: required parameter pExclusiveScissors specified as NULL");
6448 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, nullptr);
6449 m_errorMonitor->VerifyFound();
6450
6451 struct TestCase {
6452 VkRect2D scissor;
6453 std::string vuid;
6454 };
6455
6456 std::vector<TestCase> test_cases = {
6457 {{{-1, 0}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"},
6458 {{{0, -1}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"},
6459 {{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
6460 {{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
6461 {{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
6462 {{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"},
6463 {{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"},
6464 {{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"}};
6465
6466 for (const auto &test_case : test_cases) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07006467 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid);
unknown088160a2019-05-23 17:43:13 -06006468 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
6469 m_errorMonitor->VerifyFound();
6470 }
6471
6472 m_commandBuffer->end();
6473 }
6474}
6475
6476TEST_F(VkLayerTest, MeshShaderNV) {
6477 TEST_DESCRIPTION("Test VK_NV_mesh_shader.");
6478
sjfricked8e01c52022-07-06 14:09:04 +09006479 AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
6480 AddRequiredExtensions(VK_NV_MESH_SHADER_EXTENSION_NAME);
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07006481 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sjfricked8e01c52022-07-06 14:09:04 +09006482 if (!AreRequiredExtensionsEnabled()) {
6483 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
unknown088160a2019-05-23 17:43:13 -06006484 }
6485
Tony-LunarG048f5012020-04-29 16:55:11 -06006486 if (IsPlatform(kMockICD) || DeviceSimulation()) {
sjfricke11b24692022-06-21 20:49:53 +09006487 GTEST_SKIP() << "Test not supported by MockICD";
unknown088160a2019-05-23 17:43:13 -06006488 }
6489
6490 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006491 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
unknown088160a2019-05-23 17:43:13 -06006492 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
6493
6494 // Create a device that enables mesh_shader
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07006495 auto mesh_shader_features = LvlInitStruct<VkPhysicalDeviceMeshShaderFeaturesNV>();
6496 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&mesh_shader_features);
unknown088160a2019-05-23 17:43:13 -06006497 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
6498 features2.features.multiDrawIndirect = VK_FALSE;
6499
6500 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
6501 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6502
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006503 static const char vertShaderText[] = R"glsl(
6504 #version 450
6505 vec2 vertices[3];
6506 void main() {
6507 vertices[0] = vec2(-1.0, -1.0);
6508 vertices[1] = vec2( 1.0, -1.0);
6509 vertices[2] = vec2( 0.0, 1.0);
6510 gl_Position = vec4(vertices[gl_VertexIndex % 3], 0.0, 1.0);
6511 gl_PointSize = 1.0f;
6512 }
6513 )glsl";
unknown088160a2019-05-23 17:43:13 -06006514
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006515 static const char meshShaderText[] = R"glsl(
6516 #version 450
6517 #extension GL_NV_mesh_shader : require
6518 layout(local_size_x = 1) in;
6519 layout(max_vertices = 3) out;
6520 layout(max_primitives = 1) out;
6521 layout(triangles) out;
6522 void main() {
6523 gl_MeshVerticesNV[0].gl_Position = vec4(-1.0, -1.0, 0, 1);
6524 gl_MeshVerticesNV[1].gl_Position = vec4( 1.0, -1.0, 0, 1);
6525 gl_MeshVerticesNV[2].gl_Position = vec4( 0.0, 1.0, 0, 1);
6526 gl_PrimitiveIndicesNV[0] = 0;
6527 gl_PrimitiveIndicesNV[1] = 1;
6528 gl_PrimitiveIndicesNV[2] = 2;
6529 gl_PrimitiveCountNV = 1;
6530 }
6531 )glsl";
unknown088160a2019-05-23 17:43:13 -06006532
sfricke-samsungae54c1e2022-01-21 05:35:21 -08006533 VkShaderObj vs(this, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
6534 VkShaderObj ms(this, meshShaderText, VK_SHADER_STAGE_MESH_BIT_NV);
6535 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06006536
6537 // Test pipeline creation
6538 {
6539 // can't mix mesh with vertex
6540 const auto break_vp = [&](CreatePipelineHelper &helper) {
6541 helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo(), ms.GetStageCreateInfo()};
6542 };
Mark Lobodzinski20310782020-02-28 14:25:17 -07006543 CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06006544 vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02095"}));
6545
6546 // vertex or mesh must be present
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006547 // 02096 overlaps with 06896
unknown088160a2019-05-23 17:43:13 -06006548 const auto break_vp2 = [&](CreatePipelineHelper &helper) { helper.shader_stages_ = {fs.GetStageCreateInfo()}; };
Mark Lobodzinski20310782020-02-28 14:25:17 -07006549 CreatePipelineHelper::OneshotTest(*this, break_vp2, kErrorBit,
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006550 vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-stage-02096",
6551 "VUID-VkGraphicsPipelineCreateInfo-pStages-06896"}));
unknown088160a2019-05-23 17:43:13 -06006552
6553 // vertexinput and inputassembly must be valid when vertex stage is present
6554 const auto break_vp3 = [&](CreatePipelineHelper &helper) {
6555 helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
6556 helper.gp_ci_.pVertexInputState = nullptr;
6557 helper.gp_ci_.pInputAssemblyState = nullptr;
6558 };
Mark Lobodzinski20310782020-02-28 14:25:17 -07006559 CreatePipelineHelper::OneshotTest(*this, break_vp3, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06006560 vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02097",
6561 "VUID-VkGraphicsPipelineCreateInfo-pStages-02098"}));
6562 }
6563
6564 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006565 (PFN_vkCmdDrawMeshTasksIndirectNV)vk::GetInstanceProcAddr(instance(), "vkCmdDrawMeshTasksIndirectNV");
unknown088160a2019-05-23 17:43:13 -06006566
sfricke-samsung1c61f192021-12-31 01:53:03 -06006567 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
unknown088160a2019-05-23 17:43:13 -06006568 buffer_create_info.size = sizeof(uint32_t);
6569 buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
6570 VkBuffer buffer;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006571 VkResult result = vk::CreateBuffer(m_device->device(), &buffer_create_info, nullptr, &buffer);
unknown088160a2019-05-23 17:43:13 -06006572 ASSERT_VK_SUCCESS(result);
6573
6574 m_commandBuffer->begin();
6575
Mark Lobodzinski20310782020-02-28 14:25:17 -07006576 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146");
6577 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718");
unknown088160a2019-05-23 17:43:13 -06006578 vkCmdDrawMeshTasksIndirectNV(m_commandBuffer->handle(), buffer, 0, 2, 0);
6579 m_errorMonitor->VerifyFound();
6580
6581 m_commandBuffer->end();
6582
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006583 vk::DestroyBuffer(m_device->device(), buffer, 0);
unknown088160a2019-05-23 17:43:13 -06006584}
6585
6586TEST_F(VkLayerTest, MeshShaderDisabledNV) {
6587 TEST_DESCRIPTION("Test VK_NV_mesh_shader VUs with NV_mesh_shader disabled.");
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006588
sjfricked700bc02022-05-30 16:35:06 +09006589 AddRequiredExtensions(VK_NV_MESH_SHADER_EXTENSION_NAME);
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006590 ASSERT_NO_FATAL_FAILURE(InitFramework());
sjfricked700bc02022-05-30 16:35:06 +09006591 if (!AreRequiredExtensionsEnabled()) {
6592 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006593 }
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006594
6595 auto mesh_shader_features = LvlInitStruct<VkPhysicalDeviceMeshShaderFeaturesNV>();
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006596 GetPhysicalDeviceFeatures2(mesh_shader_features);
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006597 if (mesh_shader_features.meshShader != VK_TRUE) {
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006598 GTEST_SKIP() << "Mesh shader feature not supported";
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006599 }
6600
6601 mesh_shader_features.meshShader = VK_FALSE;
6602 mesh_shader_features.taskShader = VK_FALSE;
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006603 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &mesh_shader_features));
unknown088160a2019-05-23 17:43:13 -06006604 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6605
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006606 vk_testing::Event event_obj(*m_device);
6607 const auto event = event_obj.handle();
6608 ASSERT_TRUE(event_obj.initialized());
unknown088160a2019-05-23 17:43:13 -06006609
6610 m_commandBuffer->begin();
6611
Shannon McPherson93970b12020-06-12 14:34:35 -06006612 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-04095");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006613 vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06006614 m_errorMonitor->VerifyFound();
6615
Shannon McPherson93970b12020-06-12 14:34:35 -06006616 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-04096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006617 vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06006618 m_errorMonitor->VerifyFound();
6619
Shannon McPherson93970b12020-06-12 14:34:35 -06006620 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-04095");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006621 vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06006622 m_errorMonitor->VerifyFound();
6623
Shannon McPherson93970b12020-06-12 14:34:35 -06006624 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-04096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006625 vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06006626 m_errorMonitor->VerifyFound();
6627
Shannon McPherson93970b12020-06-12 14:34:35 -06006628 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-04095");
6629 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-04095");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006630 vk::CmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
6631 VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06006632 m_errorMonitor->VerifyFound();
6633
Shannon McPherson93970b12020-06-12 14:34:35 -06006634 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-04096");
6635 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-04096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006636 vk::CmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
6637 VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06006638 m_errorMonitor->VerifyFound();
6639
Shannon McPherson93970b12020-06-12 14:34:35 -06006640 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-04095");
6641 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-04095");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006642 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0,
6643 0, nullptr, 0, nullptr, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06006644 m_errorMonitor->VerifyFound();
6645
Shannon McPherson93970b12020-06-12 14:34:35 -06006646 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-04096");
6647 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-04096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006648 vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0,
6649 0, nullptr, 0, nullptr, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06006650 m_errorMonitor->VerifyFound();
6651
6652 m_commandBuffer->end();
6653
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006654 vk_testing::Semaphore semaphore_obj(*m_device);
6655 const auto semaphore = semaphore_obj.handle();
6656 ASSERT_TRUE(semaphore_obj.initialized());
unknown088160a2019-05-23 17:43:13 -06006657
6658 VkPipelineStageFlags stage_flags = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV | VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV;
sfricke-samsung1c61f192021-12-31 01:53:03 -06006659 VkSubmitInfo submit_info = LvlInitStruct<VkSubmitInfo>();
unknown088160a2019-05-23 17:43:13 -06006660
6661 // Signal the semaphore so the next test can wait on it.
unknown088160a2019-05-23 17:43:13 -06006662 submit_info.signalSemaphoreCount = 1;
6663 submit_info.pSignalSemaphores = &semaphore;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006664 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06006665
unknown088160a2019-05-23 17:43:13 -06006666 submit_info.signalSemaphoreCount = 0;
6667 submit_info.pSignalSemaphores = nullptr;
6668 submit_info.waitSemaphoreCount = 1;
6669 submit_info.pWaitSemaphores = &semaphore;
6670 submit_info.pWaitDstStageMask = &stage_flags;
6671
sfricke-samsung1ac64842021-09-23 14:11:17 -07006672 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-04095");
6673 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-04096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006674 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06006675 m_errorMonitor->VerifyFound();
6676
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006677 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06006678
sfricke-samsungae54c1e2022-01-21 05:35:21 -08006679 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006680
6681 static const char task_src[] = R"glsl(
6682 #version 450
6683
6684 #extension GL_NV_mesh_shader : require
6685
6686 layout(local_size_x = 32) in;
6687
6688 taskNV out Task {
6689 uint baseID;
6690 } OUT;
6691
6692 void main() {
6693 OUT.baseID = 1;
6694 }
6695 )glsl";
6696
6697 static const char mesh_src[] = R"glsl(
6698 #version 450
6699
6700 #extension GL_NV_mesh_shader : require
6701
6702 layout(local_size_x = 1) in;
6703 layout(max_vertices = 3) out;
6704 layout(max_primitives = 1) out;
6705 layout(triangles) out;
6706
6707 taskNV in Task {
6708 uint baseID;
6709 } IN;
6710
6711 void main() {
6712 }
6713 )glsl";
6714
6715 VkShaderObj task_shader(this, task_src, VK_SHADER_STAGE_TASK_BIT_NV);
6716 VkShaderObj mesh_shader(this, mesh_src, VK_SHADER_STAGE_MESH_BIT_NV);
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006717 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
unknown088160a2019-05-23 17:43:13 -06006718
6719 // mesh and task shaders not supported
6720 const auto break_vp = [&](CreatePipelineHelper &helper) {
Nathaniel Cesario13da77b2022-07-15 14:51:12 -06006721 helper.shader_stages_ = {task_shader.GetStageCreateInfo(), mesh_shader.GetStageCreateInfo(), fs.GetStageCreateInfo()};
unknown088160a2019-05-23 17:43:13 -06006722 };
Nathaniel Cesariofe8d7862022-02-16 17:27:29 -07006723 CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit,
6724 vector<std::string>({"VUID-VkPipelineShaderStageCreateInfo-stage-02091",
6725 "VUID-VkPipelineShaderStageCreateInfo-stage-02092"}));
unknown088160a2019-05-23 17:43:13 -06006726}
Chris Mayerc93536f2019-09-19 16:34:49 +02006727
6728TEST_F(VkLayerTest, ViewportWScalingNV) {
6729 TEST_DESCRIPTION("Verify VK_NV_clip_space_w_scaling");
6730
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07006731 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Chris Mayerc93536f2019-09-19 16:34:49 +02006732
6733 VkPhysicalDeviceFeatures device_features = {};
6734 ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
6735
6736 if (!device_features.multiViewport) {
6737 printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported, skipping tests\n", kSkipPrefix);
6738 return;
6739 }
6740
6741 if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME)) {
6742 m_device_extension_names.push_back(VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME);
6743 } else {
6744 printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME);
6745 return;
6746 }
6747
6748 ASSERT_NO_FATAL_FAILURE(InitState(&device_features));
6749 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6750
6751 auto vkCmdSetViewportWScalingNV =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006752 reinterpret_cast<PFN_vkCmdSetViewportWScalingNV>(vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetViewportWScalingNV"));
Chris Mayerc93536f2019-09-19 16:34:49 +02006753
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006754 const char vs_src[] = R"glsl(
Chris Mayerc93536f2019-09-19 16:34:49 +02006755 #version 450
6756 const vec2 positions[] = { vec2(-1.0f, 1.0f),
6757 vec2( 1.0f, 1.0f),
6758 vec2(-1.0f, -1.0f),
6759 vec2( 1.0f, -1.0f) };
6760 out gl_PerVertex {
6761 vec4 gl_Position;
6762 };
6763
6764 void main() {
6765 gl_Position = vec4(positions[gl_VertexIndex % 4], 0.0f, 1.0f);
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006766 }
6767 )glsl";
Chris Mayerc93536f2019-09-19 16:34:49 +02006768
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006769 const char fs_src[] = R"glsl(
Chris Mayerc93536f2019-09-19 16:34:49 +02006770 #version 450
6771 layout(location = 0) out vec4 outColor;
6772
6773 void main() {
6774 outColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07006775 }
6776 )glsl";
Chris Mayerc93536f2019-09-19 16:34:49 +02006777
6778 const std::vector<VkViewport> vp = {
6779 {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}};
6780 const std::vector<VkRect2D> sc = {{{0, 0}, {32, 32}}, {{32, 0}, {32, 32}}, {{0, 32}, {32, 32}}, {{32, 32}, {32, 32}}};
6781 const std::vector<VkViewportWScalingNV> scale = {{-0.2f, -0.2f}, {0.2f, -0.2f}, {-0.2f, 0.2f}, {0.2f, 0.2f}};
6782
6783 const uint32_t vp_count = static_cast<uint32_t>(vp.size());
6784
sfricke-samsung1c61f192021-12-31 01:53:03 -06006785 VkPipelineViewportWScalingStateCreateInfoNV vpsi = LvlInitStruct<VkPipelineViewportWScalingStateCreateInfoNV>();
Chris Mayerc93536f2019-09-19 16:34:49 +02006786 vpsi.viewportWScalingEnable = VK_TRUE;
6787 vpsi.viewportCount = vp_count;
6788 vpsi.pViewportWScalings = scale.data();
6789
sfricke-samsung1c61f192021-12-31 01:53:03 -06006790 VkPipelineViewportStateCreateInfo vpci = LvlInitStruct<VkPipelineViewportStateCreateInfo>(&vpsi);
Chris Mayerc93536f2019-09-19 16:34:49 +02006791 vpci.viewportCount = vp_count;
6792 vpci.pViewports = vp.data();
6793 vpci.scissorCount = vp_count;
6794 vpci.pScissors = sc.data();
Chris Mayerc93536f2019-09-19 16:34:49 +02006795
6796 const auto set_vpci = [&vpci](CreatePipelineHelper &helper) { helper.vp_state_ci_ = vpci; };
6797
6798 // Make sure no errors show up when creating the pipeline with w-scaling enabled
Nathaniel Cesariocabaf442022-07-21 14:57:41 -06006799 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit);
Chris Mayerc93536f2019-09-19 16:34:49 +02006800
6801 // Create pipeline with w-scaling enabled but without a valid scaling array
6802 vpsi.pViewportWScalings = nullptr;
Mark Lobodzinski20310782020-02-28 14:25:17 -07006803 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit,
Chris Mayerc93536f2019-09-19 16:34:49 +02006804 vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715"}));
6805
6806 vpsi.pViewportWScalings = scale.data();
6807
6808 // Create pipeline with w-scaling enabled but without matching viewport counts
6809 vpsi.viewportCount = 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07006810 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit,
Chris Mayerc93536f2019-09-19 16:34:49 +02006811 vector<std::string>({"VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726"}));
6812
6813 const VkPipelineLayoutObj pl(m_device);
6814
sfricke-samsungae54c1e2022-01-21 05:35:21 -08006815 VkShaderObj vs(this, vs_src, VK_SHADER_STAGE_VERTEX_BIT);
6816 VkShaderObj fs(this, fs_src, VK_SHADER_STAGE_FRAGMENT_BIT);
Chris Mayerc93536f2019-09-19 16:34:49 +02006817
6818 VkPipelineObj pipe(m_device);
6819 pipe.AddDefaultColorAttachment();
6820 pipe.AddShader(&vs);
6821 pipe.AddShader(&fs);
6822 pipe.SetViewport(vp);
6823 pipe.SetScissor(sc);
6824 pipe.CreateVKPipeline(pl.handle(), renderPass());
6825
6826 VkPipelineObj pipeDynWScale(m_device);
6827 pipeDynWScale.AddDefaultColorAttachment();
6828 pipeDynWScale.AddShader(&vs);
6829 pipeDynWScale.AddShader(&fs);
6830 pipeDynWScale.SetViewport(vp);
6831 pipeDynWScale.SetScissor(sc);
6832 pipeDynWScale.MakeDynamic(VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV);
6833 pipeDynWScale.CreateVKPipeline(pl.handle(), renderPass());
6834
6835 m_commandBuffer->begin();
6836
6837 // Bind pipeline without dynamic w scaling enabled
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006838 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
Chris Mayerc93536f2019-09-19 16:34:49 +02006839
Chris Mayerc93536f2019-09-19 16:34:49 +02006840 // Bind pipeline that has dynamic w-scaling enabled
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06006841 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeDynWScale.handle());
Chris Mayerc93536f2019-09-19 16:34:49 +02006842
6843 const auto max_vps = m_device->props.limits.maxViewports;
6844
Mark Lobodzinski20310782020-02-28 14:25:17 -07006845 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324");
Chris Mayerc93536f2019-09-19 16:34:49 +02006846 vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), 1, max_vps, scale.data());
6847 m_errorMonitor->VerifyFound();
6848
Chris Mayerc93536f2019-09-19 16:34:49 +02006849 vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), 0, vp_count, scale.data());
Chris Mayerc93536f2019-09-19 16:34:49 +02006850
6851 m_commandBuffer->end();
6852}
sfricke-samsung914e8002020-01-07 22:26:18 -08006853
6854TEST_F(VkLayerTest, CreateSamplerYcbcrConversionEnable) {
6855 TEST_DESCRIPTION("Checks samplerYcbcrConversion is enabled before calling vkCreateSamplerYcbcrConversion");
6856
6857 // Enable Sampler YCbCr Conversion req'd extensions
6858 // Only need revision 1 of vkGetPhysicalDeviceProperties2 and this allows more device capable for testing
6859 bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1);
6860 if (mp_extensions) {
6861 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
6862 }
6863 SetTargetApiVersion(VK_API_VERSION_1_1);
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07006864 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mike Schuchardt7cc57842021-09-15 10:49:59 -07006865 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung914e8002020-01-07 22:26:18 -08006866 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
6867 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
6868 mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
6869 if (mp_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07006870 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
sfricke-samsung914e8002020-01-07 22:26:18 -08006871 m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
6872 m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
6873 m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
6874 } else {
6875 printf("%s test requires Sampler YCbCr Conversion extensions, not available. Skipping.\n", kSkipPrefix);
6876 return;
6877 }
6878
6879 // Explictly not enable Ycbcr Conversion Features
sfricke-samsung1c61f192021-12-31 01:53:03 -06006880 VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcr_features = LvlInitStruct<VkPhysicalDeviceSamplerYcbcrConversionFeatures>();
sfricke-samsung914e8002020-01-07 22:26:18 -08006881 ycbcr_features.samplerYcbcrConversion = VK_FALSE;
6882 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &ycbcr_features));
6883
6884 PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionFunction =
6885 (PFN_vkCreateSamplerYcbcrConversionKHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCreateSamplerYcbcrConversionKHR");
6886 if (vkCreateSamplerYcbcrConversionFunction == nullptr) {
6887 printf("%s did not find vkCreateSamplerYcbcrConversionKHR function pointer; Skipping.\n", kSkipPrefix);
6888 return;
6889 }
6890
6891 // Create Ycbcr conversion
6892 VkSamplerYcbcrConversion conversions;
6893 VkSamplerYcbcrConversionCreateInfo ycbcr_create_info = {VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
6894 NULL,
6895 VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
6896 VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
6897 VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
6898 {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
6899 VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY},
6900 VK_CHROMA_LOCATION_COSITED_EVEN,
6901 VK_CHROMA_LOCATION_COSITED_EVEN,
6902 VK_FILTER_NEAREST,
6903 false};
6904
Mark Lobodzinski20310782020-02-28 14:25:17 -07006905 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCreateSamplerYcbcrConversion-None-01648");
sfricke-samsung914e8002020-01-07 22:26:18 -08006906 vkCreateSamplerYcbcrConversionFunction(m_device->handle(), &ycbcr_create_info, nullptr, &conversions);
6907 m_errorMonitor->VerifyFound();
Shannon McPherson50421602020-01-28 15:18:46 -07006908}
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006909
6910TEST_F(VkLayerTest, TransformFeedbackFeatureEnabled) {
6911 TEST_DESCRIPTION("VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled");
6912
sjfricked8e01c52022-07-06 14:09:04 +09006913 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006914
6915 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
6916
sjfricked8e01c52022-07-06 14:09:04 +09006917 if (!AreRequiredExtensionsEnabled()) {
6918 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006919 }
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006920
6921 {
6922 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
6923 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
6924 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
6925
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07006926 auto tf_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
6927 auto pd_features = LvlInitStruct<VkPhysicalDeviceFeatures2>(&tf_features);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006928 vkGetPhysicalDeviceFeatures2KHR(gpu(), &pd_features);
6929
6930 if (!tf_features.transformFeedback) {
6931 printf("%s transformFeedback not supported; skipped.\n", kSkipPrefix);
6932 return;
6933 }
6934 }
6935
6936 ASSERT_NO_FATAL_FAILURE(InitState());
6937 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
6938
6939 {
6940 auto vkCmdBindTransformFeedbackBuffersEXT = (PFN_vkCmdBindTransformFeedbackBuffersEXT)vk::GetDeviceProcAddr(
6941 m_device->device(), "vkCmdBindTransformFeedbackBuffersEXT");
6942 ASSERT_TRUE(vkCmdBindTransformFeedbackBuffersEXT != nullptr);
6943
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07006944 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006945 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
6946 info.size = 4;
6947 VkBufferObj buffer;
6948 buffer.init(*m_device, info);
6949 VkDeviceSize offsets[1]{};
6950
6951 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-transformFeedback-02355");
6952 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer.handle(), offsets, nullptr);
6953 m_errorMonitor->VerifyFound();
6954 }
6955
6956 {
6957 auto vkCmdBeginTransformFeedbackEXT =
6958 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
6959 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
6960
6961 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-transformFeedback-02366");
6962 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
6963 m_errorMonitor->VerifyFound();
6964 }
6965
6966 {
6967 auto vkCmdEndTransformFeedbackEXT =
6968 (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT");
6969 ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr);
6970
6971 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-transformFeedback-02374");
6972 m_errorMonitor->SetUnexpectedError("VUID-vkCmdEndTransformFeedbackEXT-None-02375");
6973 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
6974 m_errorMonitor->VerifyFound();
6975 }
6976}
6977
6978TEST_F(VkLayerTest, TransformFeedbackCmdBindTransformFeedbackBuffersEXT) {
6979 TEST_DESCRIPTION("Submit invalid arguments to vkCmdBindTransformFeedbackBuffersEXT");
6980
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006981 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
6982 ASSERT_NO_FATAL_FAILURE(InitFramework());
6983 if (!AreRequiredExtensionsEnabled()) {
6984 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006985 }
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006986
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06006987 if (IsPlatform(kGalaxyS10)) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006988 GTEST_SKIP() << "Test temporarily disabled on S10 device";
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06006989 }
6990
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006991 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07006992 auto tf_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006993 auto pd_features = GetPhysicalDeviceFeatures2(tf_features);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006994
6995 if (!tf_features.transformFeedback) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06006996 GTEST_SKIP() << "transformFeedback not supported; skipped.";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06006997 }
6998
6999 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features));
7000 }
7001
7002 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
7003
7004 auto vkCmdBindTransformFeedbackBuffersEXT =
7005 (PFN_vkCmdBindTransformFeedbackBuffersEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBindTransformFeedbackBuffersEXT");
7006 ASSERT_TRUE(vkCmdBindTransformFeedbackBuffersEXT != nullptr);
7007
7008 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007009 auto tf_properties = LvlInitStruct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007010 GetPhysicalDeviceProperties2(tf_properties);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007011
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007012 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007013 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
7014 info.size = 8;
7015 VkBufferObj const buffer_obj(*m_device, info);
7016
7017 // Request a firstBinding that is too large.
7018 {
7019 auto const firstBinding = tf_properties.maxTransformFeedbackBuffers;
7020 VkDeviceSize const offsets[1]{};
7021
7022 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02356");
7023 m_errorMonitor->SetUnexpectedError("VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357");
7024 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), firstBinding, 1, &buffer_obj.handle(), offsets,
7025 nullptr);
7026 m_errorMonitor->VerifyFound();
7027 }
7028
7029 // Request too many bindings.
7030 if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) {
7031 auto const bindingCount = tf_properties.maxTransformFeedbackBuffers + 1;
7032 std::vector<VkBuffer> buffers(bindingCount, buffer_obj.handle());
7033
7034 std::vector<VkDeviceSize> offsets(bindingCount);
7035
7036 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357");
7037 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, bindingCount, buffers.data(), offsets.data(),
7038 nullptr);
7039 m_errorMonitor->VerifyFound();
7040 }
7041
7042 // Request a size that is larger than the maximum size.
7043 if (tf_properties.maxTransformFeedbackBufferSize < std::numeric_limits<VkDeviceSize>::max()) {
7044 VkDeviceSize const offsets[1]{};
7045 VkDeviceSize const sizes[1]{tf_properties.maxTransformFeedbackBufferSize + 1};
7046
7047 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSize-02361");
7048 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes);
7049 m_errorMonitor->VerifyFound();
7050 }
7051 }
7052
7053 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007054 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007055 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
7056 info.size = 8;
7057 VkBufferObj const buffer_obj(*m_device, info);
7058
7059 // Request an offset that is too large.
7060 {
7061 VkDeviceSize const offsets[1]{info.size + 4};
7062
7063 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02358");
7064 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr);
7065 m_errorMonitor->VerifyFound();
7066 }
7067
7068 // Request an offset that is not a multiple of 4.
7069 {
7070 VkDeviceSize const offsets[1]{1};
7071
7072 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02359");
7073 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr);
7074 m_errorMonitor->VerifyFound();
7075 }
7076
7077 // Request a size that is larger than the buffer's size.
7078 {
7079 VkDeviceSize const offsets[1]{};
7080 VkDeviceSize const sizes[1]{info.size + 1};
7081
7082 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSizes-02362");
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007083 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes);
7084 m_errorMonitor->VerifyFound();
7085 }
7086
7087 // Request an offset and size whose sum is larger than the buffer's size.
7088 {
7089 VkDeviceSize const offsets[1]{4};
7090 VkDeviceSize const sizes[1]{info.size - 3};
7091
7092 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02363");
7093 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes);
7094 m_errorMonitor->VerifyFound();
7095 }
7096
7097 // Bind while transform feedback is active.
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007098 if (!IsDriver(VK_DRIVER_ID_MESA_RADV)) {
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007099 auto vkCmdBeginTransformFeedbackEXT =
7100 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
7101 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
7102 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
7103
7104 VkDeviceSize const offsets[1]{};
7105
7106 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-None-02365");
7107 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr);
7108 m_errorMonitor->VerifyFound();
7109
7110 auto vkCmdEndTransformFeedbackEXT =
7111 (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT");
7112 ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr);
7113 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
7114 }
7115 }
7116
7117 // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT.
7118 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007119 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007120 // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
7121 info.size = 4;
paul-lunargabe3b302022-07-08 15:23:08 -06007122 m_errorMonitor->SetUnexpectedError("VUID-VkBufferCreateInfo-usage-requiredbitmask");
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007123 VkBufferObj const buffer_obj(*m_device, info);
7124
7125 VkDeviceSize const offsets[1]{};
7126
7127 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02360");
7128 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr);
7129 m_errorMonitor->VerifyFound();
7130 }
7131
7132 // Don't bind memory.
7133 {
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06007134 vk_testing::Buffer buffer;
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007135 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007136 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007137 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
7138 info.size = 4;
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06007139 buffer.init_no_mem(*m_device, info);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007140 }
7141
7142 VkDeviceSize const offsets[1]{};
7143
7144 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02364");
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06007145 vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer.handle(), offsets, nullptr);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007146 m_errorMonitor->VerifyFound();
7147 }
7148}
7149
7150TEST_F(VkLayerTest, TransformFeedbackCmdBeginTransformFeedbackEXT) {
7151 TEST_DESCRIPTION("Submit invalid arguments to vkCmdBeginTransformFeedbackEXT");
7152
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007153 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
7154 ASSERT_NO_FATAL_FAILURE(InitFramework());
7155 if (!AreRequiredExtensionsEnabled()) {
7156 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007157 }
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007158
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06007159 if (IsPlatform(kGalaxyS10)) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007160 GTEST_SKIP() << "Test temporarily disabled on S10 device";
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06007161 }
7162
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007163 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007164 auto tf_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007165 auto pd_features = GetPhysicalDeviceFeatures2(tf_features);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007166
7167 if (!tf_features.transformFeedback) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007168 GTEST_SKIP() << "transformFeedback not supported; skipped.";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007169 }
7170
7171 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features));
7172 }
7173
7174 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
7175
7176 auto vkCmdBeginTransformFeedbackEXT =
7177 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
7178 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
7179
7180 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007181 auto tf_properties = LvlInitStruct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007182 GetPhysicalDeviceProperties2(tf_properties);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007183
7184 // Request a firstCounterBuffer that is too large.
7185 {
7186 auto const firstCounterBuffer = tf_properties.maxTransformFeedbackBuffers;
7187
7188 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02368");
7189 m_errorMonitor->SetUnexpectedError("VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369");
7190 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), firstCounterBuffer, 1, nullptr, nullptr);
7191 m_errorMonitor->VerifyFound();
7192 }
7193
7194 // Request too many buffers.
7195 if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) {
7196 auto const counterBufferCount = tf_properties.maxTransformFeedbackBuffers + 1;
7197
7198 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369");
7199 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, counterBufferCount, nullptr, nullptr);
7200 m_errorMonitor->VerifyFound();
7201 }
7202 }
7203
7204 // Request an out-of-bounds location.
7205 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007206 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007207 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
7208 info.size = 4;
7209 VkBufferObj const buffer_obj(*m_device, info);
7210
7211 VkDeviceSize const offsets[1]{1};
7212
7213 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-02370");
7214 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets);
7215 m_errorMonitor->VerifyFound();
7216 }
7217
7218 // Request specific offsets without specifying buffers.
7219 {
7220 VkDeviceSize const offsets[1]{};
7221
7222 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffer-02371");
7223 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, offsets);
7224 m_errorMonitor->VerifyFound();
7225 }
7226
7227 // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT.
7228 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007229 auto info = LvlInitStruct<VkBufferCreateInfo>();
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007230 // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
7231 info.size = 4;
paul-lunargabe3b302022-07-08 15:23:08 -06007232 m_errorMonitor->SetUnexpectedError("VUID-VkBufferCreateInfo-usage-requiredbitmask");
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007233 VkBufferObj const buffer_obj(*m_device, info);
7234
7235 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffers-02372");
7236 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), nullptr);
7237 m_errorMonitor->VerifyFound();
7238 }
7239
7240 // Begin while transform feedback is active.
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007241 if (!IsDriver(VK_DRIVER_ID_MESA_RADV)) {
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007242 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
7243
7244 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-None-02367");
7245 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
7246 m_errorMonitor->VerifyFound();
7247
7248 auto vkCmdEndTransformFeedbackEXT =
7249 (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT");
7250 ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr);
7251
7252 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
7253 }
7254}
7255
7256TEST_F(VkLayerTest, TransformFeedbackCmdEndTransformFeedbackEXT) {
7257 TEST_DESCRIPTION("Submit invalid arguments to vkCmdEndTransformFeedbackEXT");
7258
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007259 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007260 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007261 if (!AreRequiredExtensionsEnabled()) {
7262 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
7263 }
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007264
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06007265 if (IsPlatform(kGalaxyS10)) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007266 GTEST_SKIP() << "Test temporarily disabled on S10 device";
Nathaniel Cesario27d85f52021-07-22 12:42:07 -06007267 }
7268
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007269 {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007270 auto tf_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007271 auto pd_features = GetPhysicalDeviceFeatures2(tf_features);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007272
7273 if (!tf_features.transformFeedback) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007274 GTEST_SKIP() << "transformFeedback not supported; skipped.";
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007275 }
7276
7277 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features));
7278 }
7279
7280 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
7281
7282 auto vkCmdEndTransformFeedbackEXT =
7283 (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT");
7284 ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr);
7285
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007286 if (!IsDriver(VK_DRIVER_ID_MESA_RADV)) {
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007287 {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007288 // Activate transform feedback.
7289 auto vkCmdBeginTransformFeedbackEXT =
7290 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
7291 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
7292 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007293
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007294 {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007295 auto tf_properties = LvlInitStruct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
7296 GetPhysicalDeviceProperties2(tf_properties);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007297
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007298 // Request a firstCounterBuffer that is too large.
7299 {
7300 auto const firstCounterBuffer = tf_properties.maxTransformFeedbackBuffers;
7301
7302 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02376");
7303 m_errorMonitor->SetUnexpectedError("VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377");
7304 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), firstCounterBuffer, 1, nullptr, nullptr);
7305 m_errorMonitor->VerifyFound();
7306 }
7307
7308 // Request too many buffers.
7309 if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) {
7310 auto const counterBufferCount = tf_properties.maxTransformFeedbackBuffers + 1;
7311
7312 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377");
7313 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, counterBufferCount, nullptr, nullptr);
7314 m_errorMonitor->VerifyFound();
7315 }
7316 }
7317
7318 // Request an out-of-bounds location.
7319 {
7320 auto info = LvlInitStruct<VkBufferCreateInfo>();
7321 info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
7322 info.size = 4;
7323 VkBufferObj const buffer_obj(*m_device, info);
7324
7325 VkDeviceSize const offsets[1]{1};
7326
7327 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBufferOffsets-02378");
7328 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007329 m_errorMonitor->VerifyFound();
7330 }
7331
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007332 // Request specific offsets without specifying buffers.
7333 {
7334 VkDeviceSize const offsets[1]{};
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007335
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007336 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffer-02379");
7337 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, offsets);
7338 m_errorMonitor->VerifyFound();
7339 }
7340
7341 // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT.
7342 {
7343 auto info = LvlInitStruct<VkBufferCreateInfo>();
7344 // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
7345 info.size = 4;
paul-lunargabe3b302022-07-08 15:23:08 -06007346 m_errorMonitor->SetUnexpectedError("VUID-VkBufferCreateInfo-usage-requiredbitmask");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007347 VkBufferObj const buffer_obj(*m_device, info);
7348
7349 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffers-02380");
7350 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), nullptr);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007351 m_errorMonitor->VerifyFound();
7352 }
7353 }
7354
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007355 // End while transform feedback is inactive.
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007356 {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007357 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007358
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06007359 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-None-02375");
7360 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007361 m_errorMonitor->VerifyFound();
7362 }
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06007363 }
7364}
sfricke-samsung071af2d2020-07-02 10:37:22 -07007365
sfricke-samsung39ee2442020-07-22 21:21:15 -07007366TEST_F(VkLayerTest, InvalidUnprotectedCommands) {
7367 TEST_DESCRIPTION("Test making commands in unprotected command buffers that can't be used");
sfricke-samsung071af2d2020-07-02 10:37:22 -07007368
7369 // protect memory added in VK 1.1
7370 SetTargetApiVersion(VK_API_VERSION_1_1);
7371
sjfricked8e01c52022-07-06 14:09:04 +09007372 AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
7373
sfricke-samsung071af2d2020-07-02 10:37:22 -07007374 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
7375
sjfricked8e01c52022-07-06 14:09:04 +09007376 if (!AreRequiredExtensionsEnabled()) {
7377 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
7378 }
7379
sfricke-samsung071af2d2020-07-02 10:37:22 -07007380 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
7381 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
7382 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
7383
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007384 auto protected_memory_features = LvlInitStruct<VkPhysicalDeviceProtectedMemoryFeatures>();
7385 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&protected_memory_features);
sfricke-samsung071af2d2020-07-02 10:37:22 -07007386 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
7387
7388 if (protected_memory_features.protectedMemory == VK_FALSE) {
7389 printf("%s protectedMemory feature not supported, skipped.\n", kSkipPrefix);
7390 return;
7391 };
7392
7393 // Turns m_commandBuffer into a protected command buffer
7394 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_PROTECTED_BIT));
7395
7396 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
7397 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09007398 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
sfricke-samsung071af2d2020-07-02 10:37:22 -07007399 }
7400
7401 VkBufferObj indirect_buffer;
7402 indirect_buffer.init(*m_device, sizeof(VkDrawIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
7403 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);
7404
7405 VkBufferObj indexed_indirect_buffer;
7406 indexed_indirect_buffer.init(*m_device, sizeof(VkDrawIndexedIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
7407 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);
7408
7409 VkBufferObj index_buffer;
7410 index_buffer.init(*m_device, sizeof(uint32_t), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
7411
7412 CreatePipelineHelper pipe(*this);
7413 pipe.InitInfo();
7414 pipe.InitState();
7415 pipe.CreateGraphicsPipeline();
7416
sfricke-samsung39ee2442020-07-22 21:21:15 -07007417 VkQueryPool query_pool;
sfricke-samsung1c61f192021-12-31 01:53:03 -06007418 VkQueryPoolCreateInfo query_pool_create_info = LvlInitStruct<VkQueryPoolCreateInfo>();
sfricke-samsung39ee2442020-07-22 21:21:15 -07007419 query_pool_create_info.queryType = VK_QUERY_TYPE_OCCLUSION;
7420 query_pool_create_info.queryCount = 1;
7421 vk::CreateQueryPool(m_device->device(), &query_pool_create_info, nullptr, &query_pool);
7422
sfricke-samsung071af2d2020-07-02 10:37:22 -07007423 m_commandBuffer->begin();
7424 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
7425
7426 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
7427
7428 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirect-commandBuffer-02711");
7429 vk::CmdDrawIndirect(m_commandBuffer->handle(), indirect_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand));
7430 m_errorMonitor->VerifyFound();
7431
7432 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
7433
7434 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711");
7435 vk::CmdDrawIndexedIndirect(m_commandBuffer->handle(), indexed_indirect_buffer.handle(), 0, 1,
7436 sizeof(VkDrawIndexedIndirectCommand));
7437 m_errorMonitor->VerifyFound();
7438
7439 m_commandBuffer->EndRenderPass();
sfricke-samsung39ee2442020-07-22 21:21:15 -07007440
7441 // Query should be outside renderpass
7442 vk::CmdResetQueryPool(m_commandBuffer->handle(), query_pool, 0, 1);
7443
7444 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginQuery-commandBuffer-01885");
7445 vk::CmdBeginQuery(m_commandBuffer->handle(), query_pool, 0, 0);
7446 m_errorMonitor->VerifyFound();
7447
7448 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndQuery-commandBuffer-01886");
7449 m_errorMonitor->SetUnexpectedError("VUID-vkCmdEndQuery-None-01923");
7450 vk::CmdEndQuery(m_commandBuffer->handle(), query_pool, 0);
7451 m_errorMonitor->VerifyFound();
7452
sfricke-samsung071af2d2020-07-02 10:37:22 -07007453 m_commandBuffer->end();
sfricke-samsung39ee2442020-07-22 21:21:15 -07007454
7455 vk::DestroyQueryPool(m_device->device(), query_pool, nullptr);
sfricke-samsung071af2d2020-07-02 10:37:22 -07007456}
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007457
7458TEST_F(VkLayerTest, InvalidMixingProtectedResources) {
7459 TEST_DESCRIPTION("Test where there is mixing of protectedMemory backed resource in command buffers");
7460
7461 SetTargetApiVersion(VK_API_VERSION_1_1);
sjfricked8e01c52022-07-06 14:09:04 +09007462 AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007463
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007464 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
7465
Mark Lobodzinskic2312742020-08-05 13:57:11 -06007466 if (IsPlatform(kShieldTV) || IsPlatform(kShieldTVb)) {
7467 printf("%s CreateImageView calls crash ShieldTV, skipped for this platform.\n", kSkipPrefix);
7468 return;
7469 }
sjfricked8e01c52022-07-06 14:09:04 +09007470 if (!AreRequiredExtensionsEnabled()) {
7471 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
7472 }
Mark Lobodzinskic2312742020-08-05 13:57:11 -06007473
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007474 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
7475 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
7476 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
sfricke-samsung21286f82021-11-16 08:21:46 -08007477 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR =
7478 (PFN_vkGetPhysicalDeviceProperties2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceProperties2KHR");
7479 ASSERT_TRUE(vkGetPhysicalDeviceProperties2KHR != nullptr);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007480
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07007481 auto protected_memory_features = LvlInitStruct<VkPhysicalDeviceProtectedMemoryFeatures>();
7482 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&protected_memory_features);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007483 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
7484
7485 if (protected_memory_features.protectedMemory == VK_FALSE) {
7486 printf("%s protectedMemory feature not supported, skipped.\n", kSkipPrefix);
7487 return;
7488 };
7489
sfricke-samsung21286f82021-11-16 08:21:46 -08007490 VkPhysicalDeviceProtectedMemoryProperties protected_memory_properties =
7491 LvlInitStruct<VkPhysicalDeviceProtectedMemoryProperties>();
7492 VkPhysicalDeviceProperties2KHR properties2 = LvlInitStruct<VkPhysicalDeviceProperties2KHR>(&protected_memory_properties);
7493 vkGetPhysicalDeviceProperties2KHR(gpu(), &properties2);
7494
7495 // Turns m_commandBuffer into a unprotected command buffer without passing in a VkCommandPoolCreateFlags
sjfricke8ab00c12022-07-08 17:33:48 +09007496 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007497
7498 VkCommandPoolObj protectedCommandPool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_PROTECTED_BIT);
7499 VkCommandBufferObj protectedCommandBuffer(m_device, &protectedCommandPool);
7500
7501 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09007502 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007503 }
7504
7505 // Create actual protected and unprotected buffers
7506 VkBuffer buffer_protected = VK_NULL_HANDLE;
7507 VkBuffer buffer_unprotected = VK_NULL_HANDLE;
sfricke-samsung1c61f192021-12-31 01:53:03 -06007508 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007509 buffer_create_info.size = 1 << 20; // 1 MB
locke-lunarg0de02522020-10-27 22:55:17 -06007510 buffer_create_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
7511 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
7512 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007513 buffer_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
7514
7515 buffer_create_info.flags = VK_BUFFER_CREATE_PROTECTED_BIT;
7516 vk::CreateBuffer(device(), &buffer_create_info, nullptr, &buffer_protected);
7517 buffer_create_info.flags = 0;
7518 vk::CreateBuffer(device(), &buffer_create_info, nullptr, &buffer_unprotected);
7519
7520 // Create actual protected and unprotected images
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007521 const VkFormat image_format = VK_FORMAT_R8G8B8A8_UNORM;
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007522 VkImageObj image_protected(m_device);
7523 VkImageObj image_unprotected(m_device);
locke-lunarg0de02522020-10-27 22:55:17 -06007524 VkImageObj image_protected_descriptor(m_device);
7525 VkImageObj image_unprotected_descriptor(m_device);
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007526 VkImageView image_views[2];
locke-lunarg0de02522020-10-27 22:55:17 -06007527 VkImageView image_views_descriptor[2];
sfricke-samsung1c61f192021-12-31 01:53:03 -06007528 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007529 image_create_info.extent = {64, 64, 1};
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007530 image_create_info.format = image_format;
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007531 image_create_info.imageType = VK_IMAGE_TYPE_2D;
7532 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
locke-lunarg0de02522020-10-27 22:55:17 -06007533 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
7534 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007535 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
7536 image_create_info.arrayLayers = 1;
7537 image_create_info.mipLevels = 1;
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007538 image_create_info.flags = VK_IMAGE_CREATE_PROTECTED_BIT;
7539 image_protected.init_no_mem(*m_device, image_create_info);
locke-lunarg0de02522020-10-27 22:55:17 -06007540 image_protected_descriptor.init_no_mem(*m_device, image_create_info);
locke-lunarg0de02522020-10-27 22:55:17 -06007541
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007542 image_create_info.flags = 0;
7543 image_unprotected.init_no_mem(*m_device, image_create_info);
locke-lunarg0de02522020-10-27 22:55:17 -06007544 image_unprotected_descriptor.init_no_mem(*m_device, image_create_info);
locke-lunarg0de02522020-10-27 22:55:17 -06007545
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007546 // Create protected and unproteced memory
7547 VkDeviceMemory memory_protected = VK_NULL_HANDLE;
7548 VkDeviceMemory memory_unprotected = VK_NULL_HANDLE;
7549
sfricke-samsung1c61f192021-12-31 01:53:03 -06007550 VkMemoryAllocateInfo alloc_info = LvlInitStruct<VkMemoryAllocateInfo>();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007551 alloc_info.allocationSize = 0;
7552
7553 // set allocationSize to buffer as it will be larger than the image, but query image to avoid BP warning
7554 VkMemoryRequirements mem_reqs_protected;
7555 vk::GetImageMemoryRequirements(device(), image_protected.handle(), &mem_reqs_protected);
7556 vk::GetBufferMemoryRequirements(device(), buffer_protected, &mem_reqs_protected);
7557 VkMemoryRequirements mem_reqs_unprotected;
7558 vk::GetImageMemoryRequirements(device(), image_unprotected.handle(), &mem_reqs_unprotected);
7559 vk::GetBufferMemoryRequirements(device(), buffer_unprotected, &mem_reqs_unprotected);
7560
7561 // Get memory index for a protected and unprotected memory
7562 VkPhysicalDeviceMemoryProperties phys_mem_props;
7563 vk::GetPhysicalDeviceMemoryProperties(gpu(), &phys_mem_props);
7564 uint32_t memory_type_protected = phys_mem_props.memoryTypeCount + 1;
7565 uint32_t memory_type_unprotected = phys_mem_props.memoryTypeCount + 1;
7566 for (uint32_t i = 0; i < phys_mem_props.memoryTypeCount; i++) {
7567 if ((mem_reqs_unprotected.memoryTypeBits & (1 << i)) &&
7568 ((phys_mem_props.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) ==
7569 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
7570 memory_type_unprotected = i;
7571 }
7572 // Check just protected bit is in type at all
7573 if ((mem_reqs_protected.memoryTypeBits & (1 << i)) &&
7574 ((phys_mem_props.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_PROTECTED_BIT) != 0)) {
7575 memory_type_protected = i;
7576 }
7577 }
7578 if ((memory_type_protected >= phys_mem_props.memoryTypeCount) || (memory_type_unprotected >= phys_mem_props.memoryTypeCount)) {
7579 printf("%s No valid memory type index could be found; skipped.\n", kSkipPrefix);
7580 vk::DestroyBuffer(device(), buffer_protected, nullptr);
7581 vk::DestroyBuffer(device(), buffer_unprotected, nullptr);
7582 return;
7583 }
7584
7585 alloc_info.memoryTypeIndex = memory_type_protected;
7586 alloc_info.allocationSize = mem_reqs_protected.size;
7587 vk::AllocateMemory(device(), &alloc_info, NULL, &memory_protected);
7588
7589 alloc_info.allocationSize = mem_reqs_unprotected.size;
7590 alloc_info.memoryTypeIndex = memory_type_unprotected;
7591 vk::AllocateMemory(device(), &alloc_info, NULL, &memory_unprotected);
7592
7593 vk::BindBufferMemory(device(), buffer_protected, memory_protected, 0);
7594 vk::BindBufferMemory(device(), buffer_unprotected, memory_unprotected, 0);
7595 vk::BindImageMemory(device(), image_protected.handle(), memory_protected, 0);
7596 vk::BindImageMemory(device(), image_unprotected.handle(), memory_unprotected, 0);
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007597 vk::BindImageMemory(device(), image_protected_descriptor.handle(), memory_protected, 0);
7598 vk::BindImageMemory(device(), image_unprotected_descriptor.handle(), memory_unprotected, 0);
7599
Aitor Camacho6ba32ff2022-06-16 19:11:12 +02007600 // Change layout once memory is bound
7601 image_protected.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
7602 image_protected_descriptor.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
7603 image_unprotected.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
7604 image_unprotected_descriptor.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
7605
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007606 // need memory bound at image view creation time
7607 image_views[0] = image_protected.targetView(image_format);
7608 image_views[1] = image_unprotected.targetView(image_format);
7609 image_views_descriptor[0] = image_protected_descriptor.targetView(image_format);
7610 image_views_descriptor[1] = image_unprotected_descriptor.targetView(image_format);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007611
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007612 // A renderpass and framebuffer that contains a protected and unprotected image view
7613 VkAttachmentDescription attachments[2] = {
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007614 {0, image_format, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007615 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
7616 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
sfricke-samsung27d3c1e2021-07-16 22:36:48 -07007617 {0, image_format, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007618 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
7619 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
7620 };
7621 VkAttachmentReference references[2] = {{0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
7622 {1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}};
7623 VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 2, references, nullptr, nullptr, 0, nullptr};
7624 VkSubpassDependency dependency = {0,
7625 0,
7626 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7627 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
7628 VK_ACCESS_SHADER_WRITE_BIT,
7629 VK_ACCESS_SHADER_WRITE_BIT,
7630 VK_DEPENDENCY_BY_REGION_BIT};
7631 VkRenderPassCreateInfo render_pass_create_info = {
7632 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 2, attachments, 1, &subpass, 1, &dependency};
7633 VkRenderPass render_pass;
7634 ASSERT_VK_SUCCESS(vk::CreateRenderPass(device(), &render_pass_create_info, nullptr, &render_pass));
7635 VkFramebufferCreateInfo framebuffer_create_info = {
7636 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, render_pass, 2, image_views, 8, 8, 1};
7637 VkFramebuffer framebuffer;
7638 ASSERT_VK_SUCCESS(vk::CreateFramebuffer(device(), &framebuffer_create_info, nullptr, &framebuffer));
7639
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007640 // Various structs used for commands
7641 VkImageSubresourceLayers image_subresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
7642 VkImageBlit blit_region = {};
7643 blit_region.srcSubresource = image_subresource;
7644 blit_region.dstSubresource = image_subresource;
7645 blit_region.srcOffsets[0] = {0, 0, 0};
7646 blit_region.srcOffsets[1] = {8, 8, 1};
7647 blit_region.dstOffsets[0] = {0, 8, 0};
7648 blit_region.dstOffsets[1] = {8, 8, 1};
7649 VkClearColorValue clear_color = {{0, 0, 0, 0}};
7650 VkImageSubresourceRange subresource_range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
7651 VkBufferCopy buffer_copy = {0, 0, 64};
7652 VkBufferImageCopy buffer_image_copy = {};
7653 buffer_image_copy.bufferRowLength = 0;
7654 buffer_image_copy.bufferImageHeight = 0;
7655 buffer_image_copy.imageSubresource = image_subresource;
7656 buffer_image_copy.imageOffset = {0, 0, 0};
7657 buffer_image_copy.imageExtent = {1, 1, 1};
7658 buffer_image_copy.bufferOffset = 0;
7659 VkImageCopy image_copy = {};
7660 image_copy.srcSubresource = image_subresource;
7661 image_copy.srcOffset = {0, 0, 0};
7662 image_copy.dstSubresource = image_subresource;
7663 image_copy.dstOffset = {0, 0, 0};
7664 image_copy.extent = {1, 1, 1};
7665 uint32_t update_data[4] = {0, 0, 0, 0};
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007666 VkRect2D render_area = {{0, 0}, {8, 8}};
7667 VkRenderPassBeginInfo render_pass_begin = {
7668 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, render_pass, framebuffer, render_area, 0, nullptr};
7669 VkClearAttachment clear_attachments[2] = {{VK_IMAGE_ASPECT_COLOR_BIT, 0, {m_clear_color}},
7670 {VK_IMAGE_ASPECT_COLOR_BIT, 1, {m_clear_color}}};
7671 VkClearRect clear_rect[2] = {{render_area, 0, 1}, {render_area, 0, 1}};
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007672
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07007673 const char fsSource[] = R"glsl(
7674 #version 450
7675 layout(set=0, binding=0) uniform foo { int x; int y; } bar;
7676 layout(set=0, binding=1, rgba8) uniform image2D si1;
7677 layout(location=0) out vec4 x;
7678 void main(){
7679 x = vec4(bar.y);
7680 imageStore(si1, ivec2(0), vec4(0));
7681 }
7682 )glsl";
sfricke-samsungae54c1e2022-01-21 05:35:21 -08007683 VkShaderObj fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
locke-lunarg0de02522020-10-27 22:55:17 -06007684
aitor-lunargf15acd52022-03-09 22:13:25 +01007685 CreatePipelineHelper g_pipe(*this, 2u);
locke-lunarg0de02522020-10-27 22:55:17 -06007686 g_pipe.InitInfo();
7687 g_pipe.gp_ci_.renderPass = render_pass;
7688 g_pipe.shader_stages_ = {g_pipe.vs_->GetStageCreateInfo(), fs.GetStageCreateInfo()};
7689 g_pipe.dsl_bindings_ = {{0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
7690 {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}};
locke-lunarg0de02522020-10-27 22:55:17 -06007691 g_pipe.InitState();
7692 ASSERT_VK_SUCCESS(g_pipe.CreateGraphicsPipeline());
7693
7694 VkSampler sampler;
7695 VkSamplerCreateInfo sampler_ci = SafeSaneSamplerCreateInfo();
7696 VkResult err = vk::CreateSampler(m_device->device(), &sampler_ci, nullptr, &sampler);
7697 ASSERT_VK_SUCCESS(err);
7698
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007699 // Use protected resources in unprotected command buffer
sfricke-samsung36428462021-02-10 01:23:34 -08007700 g_pipe.descriptor_set_->WriteDescriptorBufferInfo(0, buffer_protected, 0, 1024);
locke-lunarg0de02522020-10-27 22:55:17 -06007701 g_pipe.descriptor_set_->WriteDescriptorImageInfo(1, image_views_descriptor[0], sampler, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
7702 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
7703 g_pipe.descriptor_set_->UpdateDescriptorSets();
7704
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007705 m_commandBuffer->begin();
sfricke-samsung21286f82021-11-16 08:21:46 -08007706 // will get undefined values, but not invalid if protectedNoFault is supported
7707 // Will still create an empty command buffer to test submit VUs if protectedNoFault is supported
7708 if (!protected_memory_properties.protectedNoFault) {
7709 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-commandBuffer-01834");
7710 vk::CmdBlitImage(m_commandBuffer->handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL, image_unprotected.handle(),
7711 VK_IMAGE_LAYOUT_GENERAL, 1, &blit_region, VK_FILTER_NEAREST);
7712 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007713
sfricke-samsung21286f82021-11-16 08:21:46 -08007714 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-commandBuffer-01835");
7715 vk::CmdBlitImage(m_commandBuffer->handle(), image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, image_protected.handle(),
7716 VK_IMAGE_LAYOUT_GENERAL, 1, &blit_region, VK_FILTER_NEAREST);
7717 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007718
sfricke-samsung21286f82021-11-16 08:21:46 -08007719 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-commandBuffer-01805");
7720 vk::CmdClearColorImage(m_commandBuffer->handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1,
7721 &subresource_range);
7722 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007723
sfricke-samsung21286f82021-11-16 08:21:46 -08007724 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBuffer-commandBuffer-01822");
7725 vk::CmdCopyBuffer(m_commandBuffer->handle(), buffer_protected, buffer_unprotected, 1, &buffer_copy);
7726 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007727
sfricke-samsung21286f82021-11-16 08:21:46 -08007728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBuffer-commandBuffer-01823");
7729 vk::CmdCopyBuffer(m_commandBuffer->handle(), buffer_unprotected, buffer_protected, 1, &buffer_copy);
7730 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007731
sfricke-samsung21286f82021-11-16 08:21:46 -08007732 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-01828");
7733 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_protected, image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL,
7734 1, &buffer_image_copy);
7735 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007736
sfricke-samsung21286f82021-11-16 08:21:46 -08007737 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-01829");
7738 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_unprotected, image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL,
7739 1, &buffer_image_copy);
7740 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007741
sfricke-samsung21286f82021-11-16 08:21:46 -08007742 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-commandBuffer-01825");
7743 vk::CmdCopyImage(m_commandBuffer->handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL, image_unprotected.handle(),
7744 VK_IMAGE_LAYOUT_GENERAL, 1, &image_copy);
7745 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007746
sfricke-samsung21286f82021-11-16 08:21:46 -08007747 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-commandBuffer-01826");
7748 vk::CmdCopyImage(m_commandBuffer->handle(), image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, image_protected.handle(),
7749 VK_IMAGE_LAYOUT_GENERAL, 1, &image_copy);
7750 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007751
sfricke-samsung21286f82021-11-16 08:21:46 -08007752 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831");
7753 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_unprotected,
7754 1, &buffer_image_copy);
7755 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007756
sfricke-samsung21286f82021-11-16 08:21:46 -08007757 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832");
7758 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_protected,
7759 1, &buffer_image_copy);
7760 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007761
sfricke-samsung21286f82021-11-16 08:21:46 -08007762 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdFillBuffer-commandBuffer-01811");
7763 vk::CmdFillBuffer(m_commandBuffer->handle(), buffer_protected, 0, 4, 0);
7764 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007765
sfricke-samsung21286f82021-11-16 08:21:46 -08007766 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdUpdateBuffer-commandBuffer-01813");
7767 vk::CmdUpdateBuffer(m_commandBuffer->handle(), buffer_protected, 0, 4, (void *)update_data);
7768 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007769
sfricke-samsung21286f82021-11-16 08:21:46 -08007770 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007771
sfricke-samsung21286f82021-11-16 08:21:46 -08007772 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-commandBuffer-02504");
7773 vk::CmdClearAttachments(m_commandBuffer->handle(), 2, clear_attachments, 2, clear_rect);
7774 m_errorMonitor->VerifyFound();
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007775
sfricke-samsung21286f82021-11-16 08:21:46 -08007776 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
7777 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0,
7778 1, &g_pipe.descriptor_set_->set_, 0, nullptr);
7779 VkDeviceSize offset = 0;
7780 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &buffer_protected, &offset);
7781 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), buffer_protected, 0, VK_INDEX_TYPE_UINT16);
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007782
sfricke-samsung21286f82021-11-16 08:21:46 -08007783 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02707"); // color attachment
7784 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02707"); // buffer descriptorSet
7785 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02707"); // image descriptorSet
7786 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02707"); // vertex
7787 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02707"); // index
locke-lunarg0de02522020-10-27 22:55:17 -06007788
sfricke-samsung21286f82021-11-16 08:21:46 -08007789 vk::CmdDrawIndexed(m_commandBuffer->handle(), 1, 0, 0, 0, 0);
7790 m_errorMonitor->VerifyFound();
locke-lunarg0de02522020-10-27 22:55:17 -06007791
sfricke-samsung21286f82021-11-16 08:21:46 -08007792 vk::CmdEndRenderPass(m_commandBuffer->handle());
7793 }
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007794 m_commandBuffer->end();
7795
7796 // Use unprotected resources in protected command buffer
sfricke-samsung36428462021-02-10 01:23:34 -08007797 g_pipe.descriptor_set_->WriteDescriptorBufferInfo(0, buffer_unprotected, 0, 1024);
locke-lunarg5ec8ddf2020-11-25 01:05:55 -07007798 g_pipe.descriptor_set_->WriteDescriptorImageInfo(1, image_views_descriptor[1], sampler, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
7799 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
locke-lunarg0de02522020-10-27 22:55:17 -06007800 g_pipe.descriptor_set_->UpdateDescriptorSets();
7801
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007802 protectedCommandBuffer.begin();
sfricke-samsung21286f82021-11-16 08:21:46 -08007803 if (!protected_memory_properties.protectedNoFault) {
7804 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-commandBuffer-01836");
7805 vk::CmdBlitImage(protectedCommandBuffer.handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL,
7806 image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &blit_region, VK_FILTER_NEAREST);
7807 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007808
sfricke-samsung21286f82021-11-16 08:21:46 -08007809 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-commandBuffer-01806");
7810 vk::CmdClearColorImage(protectedCommandBuffer.handle(), image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color,
7811 1, &subresource_range);
7812 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007813
sfricke-samsung21286f82021-11-16 08:21:46 -08007814 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBuffer-commandBuffer-01824");
7815 vk::CmdCopyBuffer(protectedCommandBuffer.handle(), buffer_protected, buffer_unprotected, 1, &buffer_copy);
7816 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007817
sfricke-samsung21286f82021-11-16 08:21:46 -08007818 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-01830");
7819 vk::CmdCopyBufferToImage(protectedCommandBuffer.handle(), buffer_protected, image_unprotected.handle(),
7820 VK_IMAGE_LAYOUT_GENERAL, 1, &buffer_image_copy);
7821 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007822
sfricke-samsung21286f82021-11-16 08:21:46 -08007823 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-commandBuffer-01827");
7824 vk::CmdCopyImage(protectedCommandBuffer.handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL,
7825 image_unprotected.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &image_copy);
7826 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007827
sfricke-samsung21286f82021-11-16 08:21:46 -08007828 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833");
7829 vk::CmdCopyImageToBuffer(protectedCommandBuffer.handle(), image_protected.handle(), VK_IMAGE_LAYOUT_GENERAL,
7830 buffer_unprotected, 1, &buffer_image_copy);
7831 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007832
sfricke-samsung21286f82021-11-16 08:21:46 -08007833 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdFillBuffer-commandBuffer-01812");
7834 vk::CmdFillBuffer(protectedCommandBuffer.handle(), buffer_unprotected, 0, 4, 0);
7835 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007836
sfricke-samsung21286f82021-11-16 08:21:46 -08007837 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdUpdateBuffer-commandBuffer-01814");
7838 vk::CmdUpdateBuffer(protectedCommandBuffer.handle(), buffer_unprotected, 0, 4, (void *)update_data);
7839 m_errorMonitor->VerifyFound();
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007840
sfricke-samsung21286f82021-11-16 08:21:46 -08007841 vk::CmdBeginRenderPass(protectedCommandBuffer.handle(), &render_pass_begin, VK_SUBPASS_CONTENTS_INLINE);
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007842
sfricke-samsung21286f82021-11-16 08:21:46 -08007843 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-commandBuffer-02505");
7844 vk::CmdClearAttachments(protectedCommandBuffer.handle(), 2, clear_attachments, 2, clear_rect);
7845 m_errorMonitor->VerifyFound();
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007846
sfricke-samsung21286f82021-11-16 08:21:46 -08007847 vk::CmdBindPipeline(protectedCommandBuffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
7848 vk::CmdBindDescriptorSets(protectedCommandBuffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS,
7849 g_pipe.pipeline_layout_.handle(), 0, 1, &g_pipe.descriptor_set_->set_, 0, nullptr);
7850 VkDeviceSize offset = 0;
7851 vk::CmdBindVertexBuffers(protectedCommandBuffer.handle(), 0, 1, &buffer_unprotected, &offset);
7852 vk::CmdBindIndexBuffer(protectedCommandBuffer.handle(), buffer_unprotected, 0, VK_INDEX_TYPE_UINT16);
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007853
sfricke-samsung21286f82021-11-16 08:21:46 -08007854 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02712"); // color attachment
7855 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02712"); // descriptorSet
7856 vk::CmdDrawIndexed(protectedCommandBuffer.handle(), 1, 0, 0, 0, 0);
7857 m_errorMonitor->VerifyFound();
locke-lunarg0de02522020-10-27 22:55:17 -06007858
sfricke-samsung21286f82021-11-16 08:21:46 -08007859 vk::CmdEndRenderPass(protectedCommandBuffer.handle());
7860 }
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007861 protectedCommandBuffer.end();
7862
sfricke-samsung96cd9932020-08-23 20:57:11 -07007863 // Try submitting together to test only 1 error occurs for the corresponding command buffer
7864 VkCommandBuffer comman_buffers[2] = {m_commandBuffer->handle(), protectedCommandBuffer.handle()};
7865
sfricke-samsung1c61f192021-12-31 01:53:03 -06007866 VkProtectedSubmitInfo protected_submit_info = LvlInitStruct<VkProtectedSubmitInfo>();
7867 VkSubmitInfo submit_info = LvlInitStruct<VkSubmitInfo>(&protected_submit_info);
sfricke-samsung96cd9932020-08-23 20:57:11 -07007868 submit_info.commandBufferCount = 2;
7869 submit_info.pCommandBuffers = comman_buffers;
7870
7871 protected_submit_info.protectedSubmit = VK_TRUE;
sfricke-samsung21286f82021-11-16 08:21:46 -08007872 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkQueueSubmit-queue-06448");
Shannon McPherson2c793ba2020-08-28 12:13:24 -06007873 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pNext-04148");
sfricke-samsung96cd9932020-08-23 20:57:11 -07007874 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7875 m_errorMonitor->VerifyFound();
7876
7877 protected_submit_info.protectedSubmit = VK_FALSE;
7878 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pNext-04120");
7879 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
7880 m_errorMonitor->VerifyFound();
7881
sfricke-samsung2aaf66f2020-07-24 03:26:22 -07007882 vk::DestroyBuffer(device(), buffer_protected, nullptr);
7883 vk::DestroyBuffer(device(), buffer_unprotected, nullptr);
7884 vk::FreeMemory(device(), memory_protected, nullptr);
7885 vk::FreeMemory(device(), memory_unprotected, nullptr);
sfricke-samsungc1c43b02020-08-04 00:21:48 -07007886 vk::DestroyFramebuffer(device(), framebuffer, nullptr);
7887 vk::DestroyRenderPass(device(), render_pass, nullptr);
Mark Lobodzinskic2312742020-08-05 13:57:11 -06007888}
locke-lunarg6b0de702020-08-07 17:42:13 -06007889
Tony-LunarG1ed322e2021-06-04 12:59:27 -06007890TEST_F(VkLayerTest, InvalidStorageAtomicOperation) {
locke-lunarg6b0de702020-08-07 17:42:13 -06007891 TEST_DESCRIPTION(
7892 "If storage view use atomic operation, the view's format MUST support VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT or "
7893 "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT ");
7894
sjfricked8e01c52022-07-06 14:09:04 +09007895 AddRequiredExtensions(VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME);
sfricke-samsungbbd74ca2021-08-05 01:09:56 -07007896
sjfricked8e01c52022-07-06 14:09:04 +09007897 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
7898 if (!AreRequiredExtensionsEnabled()) {
7899 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
7900 }
sfricke-samsungbbd74ca2021-08-05 01:09:56 -07007901 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
7902 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
7903 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
7904
7905 auto atomic_float_features = lvl_init_struct<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>();
7906 auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&atomic_float_features);
7907 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
7908 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
7909
7910 if (atomic_float_features.shaderImageFloat32Atomics == VK_FALSE) {
7911 printf("%s shaderImageFloat32Atomics not supported. Skipping test.\n", kSkipPrefix);
7912 return;
7913 }
locke-lunarg6b0de702020-08-07 17:42:13 -06007914
7915 VkImageUsageFlags usage = VK_IMAGE_USAGE_STORAGE_BIT;
7916 VkFormat image_format = VK_FORMAT_R8G8B8A8_UNORM; // The format doesn't support VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT to
7917 // cause DesiredFailure. VK_FORMAT_R32_UINT is right format.
7918 auto image_ci = VkImageObj::ImageCreateInfo2D(64, 64, 1, 1, image_format, usage, VK_IMAGE_TILING_OPTIMAL);
7919
7920 if (ImageFormatAndFeaturesSupported(instance(), gpu(), image_ci, VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT)) {
7921 printf("%s Cannot make VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT not supported. Skipping test.\n", kSkipPrefix);
7922 return;
7923 }
7924
7925 VkFormat buffer_view_format =
7926 VK_FORMAT_R8_UNORM; // The format doesn't support VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT to
7927 // cause DesiredFailure. VK_FORMAT_R32_UINT is right format.
7928 if (BufferFormatAndFeaturesSupported(gpu(), buffer_view_format, VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT)) {
7929 printf("%s Cannot make VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT not supported. Skipping test.\n", kSkipPrefix);
7930 return;
7931 }
Nathaniel Cesariob3f17dc2021-08-17 12:52:22 -06007932 m_errorMonitor->SetUnexpectedError("VUID-VkBufferViewCreateInfo-buffer-00934");
locke-lunarg6b0de702020-08-07 17:42:13 -06007933 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
7934
7935 VkPhysicalDeviceFeatures device_features = {};
7936 ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
7937 if (!device_features.vertexPipelineStoresAndAtomics || !device_features.fragmentStoresAndAtomics) {
7938 printf("%s vertexPipelineStoresAndAtomics & fragmentStoresAndAtomics NOT supported. skipped.\n", kSkipPrefix);
7939 return;
7940 }
7941
7942 VkImageObj image(m_device);
7943 image.Init(image_ci);
7944 VkImageView image_view = image.targetView(image_format);
7945
7946 VkSampler sampler = VK_NULL_HANDLE;
7947 VkSamplerCreateInfo sampler_info = SafeSaneSamplerCreateInfo();
7948 vk::CreateSampler(m_device->device(), &sampler_info, NULL, &sampler);
7949
7950 VkBufferObj buffer;
7951 buffer.init(*m_device, 64, 0, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
7952
sfricke-samsung1c61f192021-12-31 01:53:03 -06007953 VkBufferViewCreateInfo bvci = LvlInitStruct<VkBufferViewCreateInfo>();
locke-lunarg6b0de702020-08-07 17:42:13 -06007954 bvci.buffer = buffer.handle();
7955 bvci.format = buffer_view_format;
7956 bvci.range = VK_WHOLE_SIZE;
7957 VkBufferView buffer_view;
7958 vk::CreateBufferView(m_device->device(), &bvci, NULL, &buffer_view);
7959
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07007960 char const *fsSource = R"glsl(
7961 #version 450
7962 layout(set=0, binding=3, r32f) uniform image2D si0;
7963 layout(set=0, binding=2, r32f) uniform image2D si1[2];
7964 layout(set = 0, binding = 1, r32f) uniform imageBuffer stb2;
7965 layout(set = 0, binding = 0, r32f) uniform imageBuffer stb3[2];
7966 void main() {
7967 imageAtomicExchange(si0, ivec2(0), 1);
7968 imageAtomicExchange(si1[0], ivec2(0), 1);
7969 imageAtomicExchange(si1[1], ivec2(0), 1);
7970 imageAtomicExchange(stb2, 0, 1);
7971 imageAtomicExchange(stb3[0], 0, 1);
7972 imageAtomicExchange(stb3[1], 0, 1);
7973 }
7974 )glsl";
locke-lunarg6b0de702020-08-07 17:42:13 -06007975
sfricke-samsungae54c1e2022-01-21 05:35:21 -08007976 VkShaderObj vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
7977 VkShaderObj fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
locke-lunarg6b0de702020-08-07 17:42:13 -06007978
7979 CreatePipelineHelper g_pipe(*this);
7980 g_pipe.InitInfo();
7981 g_pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
locke-lunarg76e8dee2020-08-21 13:20:02 -06007982 g_pipe.dsl_bindings_ = {{3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
7983 {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
7984 {1, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
7985 {0, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 2, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}};
locke-lunarg6b0de702020-08-07 17:42:13 -06007986 g_pipe.InitState();
7987 ASSERT_VK_SUCCESS(g_pipe.CreateGraphicsPipeline());
7988
locke-lunarg76e8dee2020-08-21 13:20:02 -06007989 g_pipe.descriptor_set_->WriteDescriptorImageInfo(3, image_view, sampler, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
locke-lunarg6b0de702020-08-07 17:42:13 -06007990 VK_IMAGE_LAYOUT_GENERAL);
locke-lunarg76e8dee2020-08-21 13:20:02 -06007991 g_pipe.descriptor_set_->WriteDescriptorImageInfo(2, image_view, sampler, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
sfricke-samsung392ba9f2021-03-05 02:23:21 -08007992 VK_IMAGE_LAYOUT_GENERAL, 0, 2);
locke-lunarg76e8dee2020-08-21 13:20:02 -06007993 g_pipe.descriptor_set_->WriteDescriptorBufferView(1, buffer_view);
sfricke-samsung392ba9f2021-03-05 02:23:21 -08007994 g_pipe.descriptor_set_->WriteDescriptorBufferView(0, buffer_view, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 0, 2);
locke-lunarg6b0de702020-08-07 17:42:13 -06007995 g_pipe.descriptor_set_->UpdateDescriptorSets();
7996
7997 m_commandBuffer->begin();
7998 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
7999 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
8000 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0, 1,
8001 &g_pipe.descriptor_set_->set_, 0, nullptr);
8002
8003 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02691");
8004 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02691");
8005 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "UNASSIGNED-None-MismatchAtomicBufferFeature");
8006 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "UNASSIGNED-None-MismatchAtomicBufferFeature");
8007 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8008 m_errorMonitor->VerifyFound();
8009
8010 m_commandBuffer->EndRenderPass();
8011 m_commandBuffer->end();
Tony-LunarG1ed322e2021-06-04 12:59:27 -06008012 vk::DestroyBufferView(m_device->handle(), buffer_view, nullptr);
8013 vk::DestroySampler(m_device->handle(), sampler, nullptr);
locke-lunarg6b0de702020-08-07 17:42:13 -06008014}
locke-lunargae1bbab2020-09-10 11:55:56 -06008015
8016TEST_F(VkLayerTest, DrawWithoutUpdatePushConstants) {
8017 TEST_DESCRIPTION("Not every bytes in used push constant ranges has been set before Draw ");
8018
8019 ASSERT_NO_FATAL_FAILURE(Init());
8020 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8021
8022 // push constant range: 0-99
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07008023 char const *const vsSource = R"glsl(
8024 #version 450
8025 layout(push_constant, std430) uniform foo {
8026 bool b;
8027 float f2[3];
8028 vec3 v;
8029 vec4 v2[2];
8030 mat3 m;
8031 } constants;
8032 void func1( float f ){
8033 // use the whole v2[1]. byte: 48-63.
8034 vec2 v2 = constants.v2[1].yz;
8035 }
8036 void main(){
8037 // use only v2[0].z. byte: 40-43.
8038 func1( constants.v2[0].z);
8039 // index of m is variable. The all m is used. byte: 64-99.
8040 for(int i=1;i<2;++i) {
8041 vec3 v3 = constants.m[i];
8042 }
8043 }
8044 )glsl";
locke-lunargae1bbab2020-09-10 11:55:56 -06008045
8046 // push constant range: 0 - 95
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07008047 char const *const fsSource = R"glsl(
8048 #version 450
8049 struct foo1{
8050 int i[4];
8051 }f;
8052 layout(push_constant, std430) uniform foo {
8053 float x[2][2][2];
8054 foo1 s;
8055 foo1 ss[3];
8056 } constants;
8057 void main(){
8058 // use s. byte: 32-47.
8059 f = constants.s;
8060 // use every i[3] in ss. byte: 60-63, 76-79, 92-95.
8061 for(int i=1;i<2;++i) {
8062 int ii = constants.ss[i].i[3];
8063 }
8064 }
8065 )glsl";
locke-lunargae1bbab2020-09-10 11:55:56 -06008066
sfricke-samsungae54c1e2022-01-21 05:35:21 -08008067 VkShaderObj const vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
8068 VkShaderObj const fs(this, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT);
locke-lunargae1bbab2020-09-10 11:55:56 -06008069
8070 VkPushConstantRange push_constant_range = {VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 128};
8071 VkPushConstantRange push_constant_range_small = {VK_SHADER_STAGE_VERTEX_BIT, 4, 4};
8072
Aitor Camacho2933a0a2022-06-13 20:46:34 +02008073 auto pipeline_layout_info = LvlInitStruct<VkPipelineLayoutCreateInfo>();
8074 pipeline_layout_info.pushConstantRangeCount = 1;
8075 pipeline_layout_info.pPushConstantRanges = &push_constant_range;
locke-lunargae1bbab2020-09-10 11:55:56 -06008076
8077 VkPipelineLayout pipeline_layout;
8078 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_info, NULL, &pipeline_layout);
8079
8080 CreatePipelineHelper g_pipe(*this);
8081 g_pipe.InitInfo();
8082 g_pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
8083 g_pipe.pipeline_layout_ci_ = pipeline_layout_info;
8084 g_pipe.InitState();
8085 ASSERT_VK_SUCCESS(g_pipe.CreateGraphicsPipeline());
8086
8087 pipeline_layout_info.pPushConstantRanges = &push_constant_range_small;
8088 VkPipelineLayout pipeline_layout_small;
8089 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_info, NULL, &pipeline_layout_small);
8090
8091 CreatePipelineHelper g_pipe_small_range(*this);
8092 g_pipe_small_range.InitInfo();
8093 g_pipe_small_range.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
8094 g_pipe_small_range.pipeline_layout_ci_ = pipeline_layout_info;
8095 g_pipe_small_range.InitState();
8096
sfricke-samsung7699b912021-04-12 23:01:51 -07008097 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGraphicsPipelineCreateInfo-layout-00756");
8098 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGraphicsPipelineCreateInfo-layout-00756");
locke-lunargae1bbab2020-09-10 11:55:56 -06008099 g_pipe_small_range.CreateGraphicsPipeline();
8100 m_errorMonitor->VerifyFound();
8101
8102 m_commandBuffer->begin();
8103 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8104
Piers Daniella7f93b62021-11-20 12:32:04 -07008105 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-maintenance4-06425");
locke-lunargae1bbab2020-09-10 11:55:56 -06008106 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
8107 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0, 1,
8108 &g_pipe.descriptor_set_->set_, 0, nullptr);
8109 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8110 m_errorMonitor->VerifyFound();
8111
locke-lunargae1bbab2020-09-10 11:55:56 -06008112 const float dummy_values[128] = {};
locke-lunargae1bbab2020-09-10 11:55:56 -06008113
Nathaniel Cesarioee42bab2021-04-14 20:02:16 -06008114 // NOTE: these are commented out due to ambiguity around VUID 02698 and push constant lifetimes
8115 // See https://gitlab.khronos.org/vulkan/vulkan/-/issues/2602 and
8116 // https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/2689
8117 // for more details.
Piers Daniella7f93b62021-11-20 12:32:04 -07008118 // m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-maintenance4-06425");
Nathaniel Cesarioee42bab2021-04-14 20:02:16 -06008119 // vk::CmdPushConstants(m_commandBuffer->handle(), g_pipe.pipeline_layout_.handle(),
8120 // VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 96, dummy_values);
8121 // vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8122 // m_errorMonitor->VerifyFound();
8123
Piers Daniella7f93b62021-11-20 12:32:04 -07008124 // m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-maintenance4-06425");
Nathaniel Cesarioee42bab2021-04-14 20:02:16 -06008125 // vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_small, VK_SHADER_STAGE_VERTEX_BIT, 4, 4, dummy_values);
8126 // vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8127 // m_errorMonitor->VerifyFound();
locke-lunargae1bbab2020-09-10 11:55:56 -06008128
locke-lunargae1bbab2020-09-10 11:55:56 -06008129 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 32,
8130 68, dummy_values);
8131 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
paul-lunarg6b0b1f62022-07-11 14:00:48 -06008132
8133 m_commandBuffer->EndRenderPass();
8134 m_commandBuffer->end();
8135
8136 vk::DestroyPipelineLayout(m_device->handle(), pipeline_layout, nullptr);
8137 vk::DestroyPipelineLayout(m_device->handle(), pipeline_layout_small, nullptr);
locke-lunarg41b8c362020-10-16 23:30:12 -06008138}
8139
8140TEST_F(VkLayerTest, VerifyVertextBinding) {
8141 TEST_DESCRIPTION("Verify if VkPipelineVertexInputStateCreateInfo matches vkCmdBindVertexBuffers");
8142
8143 ASSERT_NO_FATAL_FAILURE(Init());
8144 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8145
8146 VkBufferObj vtx_buf;
8147 auto info = vtx_buf.create_info(32, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
8148 vtx_buf.init(*m_device, info);
8149
8150 CreatePipelineHelper pipe(*this);
8151 pipe.InitInfo();
8152 // CmdBindVertexBuffers only has binding:1. It causes 04007 & 04008 desired fail.
8153 VkVertexInputBindingDescription vtx_binding_des[3] = {
8154 {0, 64, VK_VERTEX_INPUT_RATE_VERTEX}, {1, 64, VK_VERTEX_INPUT_RATE_VERTEX}, {2, 64, VK_VERTEX_INPUT_RATE_VERTEX}};
8155
8156 // CmdBindVertexBuffers only has binding:1. It causes twice 02721 desired fail.
8157 // Plus, binding:1's offset is wrong. It causes 02721 desired fail, again.
8158 VkVertexInputAttributeDescription vtx_attri_des[3] = {{0, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 10},
8159 {1, 1, VK_FORMAT_R32G32B32A32_SFLOAT, 10},
8160 {2, 2, VK_FORMAT_R32G32B32A32_SFLOAT, 10}};
8161 pipe.vi_ci_.vertexBindingDescriptionCount = 3;
8162 pipe.vi_ci_.pVertexBindingDescriptions = vtx_binding_des;
8163 pipe.vi_ci_.vertexAttributeDescriptionCount = 3;
8164 pipe.vi_ci_.pVertexAttributeDescriptions = vtx_attri_des;
8165 pipe.InitState();
8166 pipe.CreateGraphicsPipeline();
8167
8168 m_commandBuffer->begin();
8169 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8170 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
8171 VkDeviceSize offset = 0;
8172 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 1, 1, &vtx_buf.handle(), &offset);
8173
8174 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-04008");
8175 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-04007");
8176 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02721");
8177 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02721");
8178 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02721");
8179 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8180 m_errorMonitor->VerifyFound();
locke-lunargae1bbab2020-09-10 11:55:56 -06008181
8182 m_commandBuffer->EndRenderPass();
8183 m_commandBuffer->end();
8184}
locke-lunargd7a08e92020-10-21 00:24:00 -06008185
8186TEST_F(VkLayerTest, VerifyDynamicStateSettingCommands) {
8187 TEST_DESCRIPTION("Verify if pipeline doesn't setup dynamic state, but set dynamic commands");
8188 ASSERT_NO_FATAL_FAILURE(Init());
8189 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8190
8191 CreatePipelineHelper pipe(*this);
8192 pipe.InitInfo();
8193
8194 std::vector<VkDynamicState> dyn_states = {VK_DYNAMIC_STATE_VIEWPORT};
8195
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008196 auto dyn_state_ci = LvlInitStruct<VkPipelineDynamicStateCreateInfo>();
locke-lunargd7a08e92020-10-21 00:24:00 -06008197 dyn_state_ci.dynamicStateCount = static_cast<uint32_t>(dyn_states.size());
8198 dyn_state_ci.pDynamicStates = dyn_states.data();
8199 pipe.dyn_state_ci_ = dyn_state_ci;
8200 pipe.InitState();
8201 pipe.CreateGraphicsPipeline();
8202
8203 m_commandBuffer->begin();
8204 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8205 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
8206
8207 VkViewport viewport = {0, 0, 16, 16, 0, 1};
8208 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
8209 VkRect2D scissor = {{0, 0}, {16, 16}};
8210 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
8211 vk::CmdSetLineWidth(m_commandBuffer->handle(), 1);
8212
8213 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02859");
8214 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
8215 m_errorMonitor->VerifyFound();
8216
8217 m_commandBuffer->EndRenderPass();
8218 m_commandBuffer->end();
8219}
locke-lunarg0de02522020-10-27 22:55:17 -06008220
8221TEST_F(VkLayerTest, VerifyFilterCubicSamplerInCmdDraw) {
8222 TEST_DESCRIPTION("Verify if sampler is filter cubic, image view needs to support it.");
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008223 SetTargetApiVersion(VK_API_VERSION_1_1);
8224 AddRequiredExtensions(VK_EXT_FILTER_CUBIC_EXTENSION_NAME);
8225 AddRequiredExtensions(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME);
8226 ASSERT_NO_FATAL_FAILURE(InitFramework());
8227 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
8228 GTEST_SKIP() << "Test requires at least Vulkan 1.1";
locke-lunarg0de02522020-10-27 22:55:17 -06008229 }
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008230 if (!AreRequiredExtensionsEnabled()) {
8231 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
locke-lunarg0de02522020-10-27 22:55:17 -06008232 }
8233
8234 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
8235 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8236
8237 VkImageUsageFlags usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
8238 VkFormat format = VK_FORMAT_R8G8B8A8_UNORM;
sfricke-samsung715e3d12020-12-01 22:45:49 -08008239
8240 VkFormatProperties format_props;
8241 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &format_props);
8242 if ((format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT) == 0) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008243 GTEST_SKIP() << "SAMPLED_IMAGE_FILTER_CUBIC_BIT for format is not supported.";
sfricke-samsung715e3d12020-12-01 22:45:49 -08008244 }
8245
locke-lunarg0de02522020-10-27 22:55:17 -06008246 auto image_ci = VkImageObj::ImageCreateInfo2D(128, 128, 1, 1, format, usage, VK_IMAGE_TILING_OPTIMAL);
8247 VkImageViewType imageViewType = VK_IMAGE_VIEW_TYPE_2D;
8248
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008249 auto imageview_format_info = LvlInitStruct<VkPhysicalDeviceImageViewImageFormatInfoEXT>();
locke-lunarg0de02522020-10-27 22:55:17 -06008250 imageview_format_info.imageViewType = imageViewType;
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008251 auto image_format_info = LvlInitStruct<VkPhysicalDeviceImageFormatInfo2>(&imageview_format_info);
locke-lunarg0de02522020-10-27 22:55:17 -06008252 image_format_info.type = image_ci.imageType;
8253 image_format_info.format = image_ci.format;
8254 image_format_info.tiling = image_ci.tiling;
8255 image_format_info.usage = image_ci.usage;
8256 image_format_info.flags = image_ci.flags;
8257
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008258 auto filter_cubic_props = LvlInitStruct<VkFilterCubicImageViewImageFormatPropertiesEXT>();
8259 auto image_format_properties = LvlInitStruct<VkImageFormatProperties2>(&filter_cubic_props);
locke-lunarg0de02522020-10-27 22:55:17 -06008260
8261 vk::GetPhysicalDeviceImageFormatProperties2(gpu(), &image_format_info, &image_format_properties);
8262
8263 if (filter_cubic_props.filterCubic || filter_cubic_props.filterCubicMinmax) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008264 GTEST_SKIP() << "Image and ImageView supports filter cubic ; skipped.";
locke-lunarg0de02522020-10-27 22:55:17 -06008265 }
8266
8267 VkImageObj image(m_device);
8268 image.Init(image_ci);
8269 VkImageView imageView = image.targetView(format, imageViewType);
8270
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008271 auto sampler_ci = LvlInitStruct<VkSamplerCreateInfo>();
locke-lunarg0de02522020-10-27 22:55:17 -06008272 sampler_ci.minFilter = VK_FILTER_CUBIC_EXT;
8273 sampler_ci.magFilter = VK_FILTER_CUBIC_EXT;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008274 vk_testing::Sampler sampler(*m_device, sampler_ci);
8275 ASSERT_TRUE(sampler.initialized());
locke-lunarg0de02522020-10-27 22:55:17 -06008276
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008277 auto reduction_mode_ci = LvlInitStruct<VkSamplerReductionModeCreateInfo>();
locke-lunarg0de02522020-10-27 22:55:17 -06008278 reduction_mode_ci.reductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
8279 sampler_ci.pNext = &reduction_mode_ci;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008280 vk_testing::Sampler sampler_reduction(*m_device, sampler_ci);
locke-lunarg0de02522020-10-27 22:55:17 -06008281
sfricke-samsungae54c1e2022-01-21 05:35:21 -08008282 VkShaderObj fs(this, bindStateFragSamplerShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
locke-lunarg0de02522020-10-27 22:55:17 -06008283
8284 CreatePipelineHelper g_pipe(*this);
8285 g_pipe.InitInfo();
8286 g_pipe.shader_stages_ = {g_pipe.vs_->GetStageCreateInfo(), fs.GetStageCreateInfo()};
8287 g_pipe.dsl_bindings_ = {{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}};
8288 g_pipe.InitState();
8289 ASSERT_VK_SUCCESS(g_pipe.CreateGraphicsPipeline());
8290
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008291 g_pipe.descriptor_set_->WriteDescriptorImageInfo(0, imageView, sampler_reduction.handle());
locke-lunarg0de02522020-10-27 22:55:17 -06008292 g_pipe.descriptor_set_->UpdateDescriptorSets();
8293
8294 m_commandBuffer->begin();
8295 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8296 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
8297 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0, 1,
8298 &g_pipe.descriptor_set_->set_, 0, nullptr);
8299
8300 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-filterCubicMinmax-02695");
8301 m_commandBuffer->Draw(1, 0, 0, 0);
8302 m_errorMonitor->VerifyFound();
8303
8304 m_commandBuffer->EndRenderPass();
8305 m_commandBuffer->end();
8306 m_commandBuffer->reset();
8307
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008308 g_pipe.descriptor_set_->WriteDescriptorImageInfo(0, imageView, sampler.handle());
locke-lunarg0de02522020-10-27 22:55:17 -06008309 g_pipe.descriptor_set_->UpdateDescriptorSets();
8310
8311 m_commandBuffer->begin();
8312 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8313 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
8314 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0, 1,
8315 &g_pipe.descriptor_set_->set_, 0, nullptr);
8316
8317 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-filterCubic-02694");
8318 m_commandBuffer->Draw(1, 0, 0, 0);
8319 m_errorMonitor->VerifyFound();
8320
8321 m_commandBuffer->EndRenderPass();
8322 m_commandBuffer->end();
8323}
8324
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008325TEST_F(VkLayerTest, VerifyImgFilterCubicSamplerInCmdDraw) {
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008326 TEST_DESCRIPTION("Verify if sampler is filter cubic with the VK_IMG_filter cubic extension that it's a valid ImageViewType.");
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008327
Clemens Kern5a42ea62021-09-29 16:30:23 +02008328 AddRequiredExtensions(VK_IMG_FILTER_CUBIC_EXTENSION_NAME);
8329 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sjfricked700bc02022-05-30 16:35:06 +09008330 if (!AreRequiredExtensionsEnabled()) {
8331 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008332 }
8333
8334 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
8335 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8336
8337 VkImageUsageFlags usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
8338 VkFormat format = VK_FORMAT_R8G8B8A8_UNORM;
Clemens Kern5a42ea62021-09-29 16:30:23 +02008339 auto image_ci = vk_testing::Image::create_info();
8340 image_ci.imageType = VK_IMAGE_TYPE_3D;
8341 image_ci.format = format;
8342 image_ci.extent.width = 128;
8343 image_ci.extent.height = 128;
8344 image_ci.mipLevels = 1;
8345 image_ci.arrayLayers = 1;
8346 image_ci.tiling = VK_IMAGE_TILING_OPTIMAL;
8347 image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
8348 image_ci.usage = usage;
8349 VkImageViewType imageViewType = VK_IMAGE_VIEW_TYPE_3D;
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008350
8351 VkImageObj image(m_device);
8352 image.Init(image_ci);
8353 VkImageView imageView = image.targetView(format, VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,
8354 VK_REMAINING_ARRAY_LAYERS, imageViewType);
8355
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008356 auto sampler_ci = LvlInitStruct<VkSamplerCreateInfo>();
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008357 sampler_ci.minFilter = VK_FILTER_CUBIC_EXT;
8358 sampler_ci.magFilter = VK_FILTER_CUBIC_EXT;
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06008359 vk_testing::Sampler sampler(*m_device, sampler_ci);
8360 ASSERT_TRUE(sampler.initialized());
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008361
Clemens Kern5a42ea62021-09-29 16:30:23 +02008362 static const char fs_src[] = R"glsl(
8363 #version 450
8364 layout(set=0, binding=0) uniform sampler3D s;
8365 layout(location=0) out vec4 x;
8366 void main(){
8367 x = texture(s, vec3(1));
8368 }
8369 )glsl";
sfricke-samsungae54c1e2022-01-21 05:35:21 -08008370 VkShaderObj fs(this, fs_src, VK_SHADER_STAGE_FRAGMENT_BIT);
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008371
8372 CreatePipelineHelper g_pipe(*this);
8373 g_pipe.InitInfo();
8374 g_pipe.shader_stages_ = {g_pipe.vs_->GetStageCreateInfo(), fs.GetStageCreateInfo()};
8375 g_pipe.dsl_bindings_ = {{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}};
8376 g_pipe.InitState();
8377 ASSERT_VK_SUCCESS(g_pipe.CreateGraphicsPipeline());
8378
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06008379 g_pipe.descriptor_set_->WriteDescriptorImageInfo(0, imageView, sampler.handle());
Mark Lobodzinski28168c52020-12-01 14:25:05 -07008380 g_pipe.descriptor_set_->UpdateDescriptorSets();
8381
8382 m_commandBuffer->begin();
8383 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8384 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_);
8385 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, g_pipe.pipeline_layout_.handle(), 0, 1,
8386 &g_pipe.descriptor_set_->set_, 0, nullptr);
8387
8388 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-None-02693");
8389 m_commandBuffer->Draw(1, 0, 0, 0);
8390 m_errorMonitor->VerifyFound();
8391
8392 m_commandBuffer->EndRenderPass();
8393 m_commandBuffer->end();
8394}
8395
locke-lunarg0de02522020-10-27 22:55:17 -06008396TEST_F(VkLayerTest, VerifyMaxMultiviewInstanceIndex) {
8397 TEST_DESCRIPTION("Verify if instance index in CmdDraw is greater than maxMultiviewInstanceIndex.");
sjfricked8e01c52022-07-06 14:09:04 +09008398 SetTargetApiVersion(VK_API_VERSION_1_1);
8399 AddRequiredExtensions(VK_KHR_MULTIVIEW_EXTENSION_NAME);
locke-lunarg0de02522020-10-27 22:55:17 -06008400 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8401
sjfricked8e01c52022-07-06 14:09:04 +09008402 if (!AreRequiredExtensionsEnabled()) {
8403 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
8404 }
8405 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
8406 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
locke-lunarg0de02522020-10-27 22:55:17 -06008407 }
8408
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008409 auto multiview_features = LvlInitStruct<VkPhysicalDeviceMultiviewFeatures>();
locke-lunarg0de02522020-10-27 22:55:17 -06008410 multiview_features.multiview = VK_TRUE;
sfricke-samsung1c61f192021-12-31 01:53:03 -06008411 VkPhysicalDeviceFeatures2 pd_features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&multiview_features);
locke-lunarg0de02522020-10-27 22:55:17 -06008412
8413 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features2));
8414 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8415
8416 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR =
8417 (PFN_vkGetPhysicalDeviceProperties2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceProperties2KHR");
8418 ASSERT_TRUE(vkGetPhysicalDeviceProperties2KHR != nullptr);
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008419 auto multiview_props = LvlInitStruct<VkPhysicalDeviceMultiviewProperties>();
8420 VkPhysicalDeviceProperties2KHR properties2 = LvlInitStruct<VkPhysicalDeviceProperties2KHR>(&multiview_props);
locke-lunarg0de02522020-10-27 22:55:17 -06008421 vkGetPhysicalDeviceProperties2KHR(gpu(), &properties2);
8422 if (multiview_props.maxMultiviewInstanceIndex == std::numeric_limits<uint32_t>::max()) {
8423 printf("%s maxMultiviewInstanceIndex is uint32_t max, skipping tests\n", kSkipPrefix);
8424 return;
8425 }
8426 CreatePipelineHelper pipe(*this);
8427 pipe.InitInfo();
8428 pipe.InitState();
8429 pipe.CreateGraphicsPipeline();
8430
8431 m_commandBuffer->begin();
8432 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8433 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
8434
8435 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDraw-maxMultiviewInstanceIndex-02688");
8436 m_commandBuffer->Draw(1, multiview_props.maxMultiviewInstanceIndex + 1, 0, 0);
8437 m_errorMonitor->VerifyFound();
8438
8439 m_commandBuffer->EndRenderPass();
8440 m_commandBuffer->end();
8441}
Tobias Hector04f2ab22020-12-01 10:59:33 +00008442
8443TEST_F(VkLayerTest, InvalidSetFragmentShadingRateValues) {
8444 TEST_DESCRIPTION("Specify invalid fragment shading rate values");
8445
8446 // Enable KHR_fragment_shading_rate and all of its required extensions
8447 bool fsr_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8448 if (fsr_extensions) {
8449 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8450 }
8451 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8452
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008453 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8454 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008455 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME);
8456 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8457 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8458 if (fsr_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008459 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8460 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008461 m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
8462 m_device_extension_names.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8463 m_device_extension_names.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8464 } else {
8465 printf("%s requires VK_KHR_fragment_shading_rate.\n", kSkipPrefix);
8466 return;
8467 }
8468
sfricke-samsung1c61f192021-12-31 01:53:03 -06008469 VkPhysicalDeviceFragmentShadingRateFeaturesKHR fsr_features = LvlInitStruct<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
Tobias Hector04f2ab22020-12-01 10:59:33 +00008470 fsr_features.pipelineFragmentShadingRate = true;
8471
sfricke-samsung1c61f192021-12-31 01:53:03 -06008472 VkPhysicalDeviceFeatures2 device_features = LvlInitStruct<VkPhysicalDeviceFeatures2>(&fsr_features);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008473
8474 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &device_features));
8475
8476 // Find address of extension call and make the call
8477 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR =
8478 (PFN_vkCmdSetFragmentShadingRateKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetFragmentShadingRateKHR");
8479 ASSERT_TRUE(vkCmdSetFragmentShadingRateKHR != nullptr);
8480
8481 VkExtent2D fragmentSize = {1, 1};
8482 VkFragmentShadingRateCombinerOpKHR combinerOps[2] = {VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
8483 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR};
8484
8485 m_commandBuffer->begin();
8486 fragmentSize.width = 0;
8487 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04513");
8488 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8489 m_errorMonitor->VerifyFound();
8490 fragmentSize.width = 1;
8491
8492 fragmentSize.height = 0;
8493 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04514");
8494 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8495 m_errorMonitor->VerifyFound();
8496 fragmentSize.height = 1;
8497
8498 fragmentSize.width = 3;
8499 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04515");
8500 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8501 m_errorMonitor->VerifyFound();
8502 fragmentSize.width = 1;
8503
8504 fragmentSize.height = 3;
8505 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04516");
8506 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8507 m_errorMonitor->VerifyFound();
8508 fragmentSize.height = 1;
8509
8510 fragmentSize.width = 8;
8511 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04517");
8512 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8513 m_errorMonitor->VerifyFound();
8514 fragmentSize.width = 1;
8515
8516 fragmentSize.height = 8;
8517 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04518");
8518 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8519 m_errorMonitor->VerifyFound();
8520 fragmentSize.height = 1;
8521 m_commandBuffer->end();
8522}
8523
8524TEST_F(VkLayerTest, InvalidSetFragmentShadingRateValuesNoFeatures) {
8525 TEST_DESCRIPTION("Specify invalid fsr pipeline settings for the enabled features");
8526
8527 // Enable KHR_fragment_shading_rate and all of its required extensions
8528 bool fsr_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8529 if (fsr_extensions) {
8530 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8531 }
8532 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8533
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008534 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8535 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008536 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME);
8537 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8538 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8539 if (fsr_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008540 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8541 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008542 m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
8543 m_device_extension_names.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8544 m_device_extension_names.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8545 } else {
8546 printf("%s requires VK_KHR_fragment_shading_rate.\n", kSkipPrefix);
8547 return;
8548 }
8549
8550 ASSERT_NO_FATAL_FAILURE(InitState());
8551 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8552
8553 // Find address of extension call and make the call
8554 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR =
8555 (PFN_vkCmdSetFragmentShadingRateKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetFragmentShadingRateKHR");
8556 ASSERT_TRUE(vkCmdSetFragmentShadingRateKHR != nullptr);
8557
8558 VkExtent2D fragmentSize = {1, 1};
8559 VkFragmentShadingRateCombinerOpKHR combinerOps[2] = {VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
8560 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR};
8561
8562 m_commandBuffer->begin();
8563 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8564 "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04509");
8565 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8566 m_errorMonitor->VerifyFound();
8567 m_commandBuffer->end();
8568}
8569
8570TEST_F(VkLayerTest, InvalidSetFragmentShadingRateCombinerOpsNoFeatures) {
8571 TEST_DESCRIPTION("Specify combiner operations when only pipeline rate is supported");
8572
8573 // Enable KHR_fragment_shading_rate and all of its required extensions
8574 bool fsr_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8575 if (fsr_extensions) {
8576 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8577 }
8578 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8579
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008580 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8581 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008582 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME);
8583 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8584 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8585 if (fsr_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008586 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8587 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008588 m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
8589 m_device_extension_names.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8590 m_device_extension_names.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8591 } else {
8592 printf("%s requires VK_KHR_fragment_shading_rate.\n", kSkipPrefix);
8593 return;
8594 }
8595
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008596 VkPhysicalDeviceFragmentShadingRateFeaturesKHR fsr_features = LvlInitStruct<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
8597 VkPhysicalDeviceFeatures2KHR features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&fsr_features);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008598
8599 fsr_features.pipelineFragmentShadingRate = VK_TRUE;
8600 fsr_features.primitiveFragmentShadingRate = VK_FALSE;
8601 fsr_features.attachmentFragmentShadingRate = VK_FALSE;
8602
8603 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
8604 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8605
8606 // Find address of extension call and make the call
8607 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR =
8608 (PFN_vkCmdSetFragmentShadingRateKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetFragmentShadingRateKHR");
8609 ASSERT_TRUE(vkCmdSetFragmentShadingRateKHR != nullptr);
8610
8611 VkExtent2D fragmentSize = {1, 1};
8612 VkFragmentShadingRateCombinerOpKHR combinerOps[2] = {VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
8613 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR};
8614
8615 m_commandBuffer->begin();
8616
8617 combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR;
8618 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8619 "VUID-vkCmdSetFragmentShadingRateKHR-primitiveFragmentShadingRate-04510");
8620 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8621 m_errorMonitor->VerifyFound();
8622 combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
8623
8624 combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR;
8625 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8626 "VUID-vkCmdSetFragmentShadingRateKHR-attachmentFragmentShadingRate-04511");
8627 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8628 m_errorMonitor->VerifyFound();
8629 combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
8630
8631 m_commandBuffer->end();
8632}
8633
8634TEST_F(VkLayerTest, InvalidSetFragmentShadingRateCombinerOpsNoPipelineRate) {
8635 TEST_DESCRIPTION("Specify pipeline rate when only attachment or primitive rate are supported");
8636
8637 // Enable KHR_fragment_shading_rate and all of its required extensions
8638 bool fsr_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8639 if (fsr_extensions) {
8640 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8641 }
8642 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8643
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008644 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8645 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008646 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME);
8647 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8648 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8649 if (fsr_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008650 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8651 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008652 m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
8653 m_device_extension_names.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8654 m_device_extension_names.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8655 } else {
8656 printf("%s requires VK_KHR_fragment_shading_rate.\n", kSkipPrefix);
8657 return;
8658 }
8659
8660 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
8661 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
8662 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008663 VkPhysicalDeviceFragmentShadingRateFeaturesKHR fsr_features = LvlInitStruct<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
8664 VkPhysicalDeviceFeatures2KHR features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&fsr_features);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008665 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
8666
8667 if (fsr_features.attachmentFragmentShadingRate == VK_FALSE && fsr_features.primitiveFragmentShadingRate == VK_FALSE) {
8668 printf("%s requires attachmentFragmentShadingRate or primitiveFragmentShadingRate.\n", kSkipPrefix);
8669 return;
8670 }
8671
8672 fsr_features.pipelineFragmentShadingRate = VK_FALSE;
8673
8674 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
8675 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8676
8677 // Find address of extension call and make the call
8678 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR =
8679 (PFN_vkCmdSetFragmentShadingRateKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetFragmentShadingRateKHR");
8680 ASSERT_TRUE(vkCmdSetFragmentShadingRateKHR != nullptr);
8681
8682 VkExtent2D fragmentSize = {1, 1};
8683 VkFragmentShadingRateCombinerOpKHR combinerOps[2] = {VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
8684 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR};
8685
8686 m_commandBuffer->begin();
8687 fragmentSize.width = 2;
8688 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8689 "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04507");
8690 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8691 m_errorMonitor->VerifyFound();
8692 fragmentSize.width = 1;
8693
8694 fragmentSize.height = 2;
8695 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8696 "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04508");
8697 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8698 m_errorMonitor->VerifyFound();
8699 fragmentSize.height = 1;
8700}
8701
8702TEST_F(VkLayerTest, InvalidSetFragmentShadingRateCombinerOpsLimit) {
8703 TEST_DESCRIPTION("Specify invalid fsr pipeline settings for the enabled features");
8704
8705 // Enable KHR_fragment_shading_rate and all of its required extensions
8706 bool fsr_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8707 if (fsr_extensions) {
8708 m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
8709 }
8710 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
8711
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008712 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8713 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008714 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME);
8715 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8716 fsr_extensions = fsr_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8717 if (fsr_extensions) {
Mike Schuchardt7cc57842021-09-15 10:49:59 -07008718 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
8719 m_device_extension_names.push_back(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008720 m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
8721 m_device_extension_names.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
8722 m_device_extension_names.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8723 } else {
8724 printf("%s requires VK_KHR_fragment_shading_rate.\n", kSkipPrefix);
8725 return;
8726 }
8727
8728 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR =
8729 (PFN_vkGetPhysicalDeviceProperties2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceProperties2KHR");
8730 ASSERT_TRUE(vkGetPhysicalDeviceProperties2KHR != nullptr);
8731 VkPhysicalDeviceFragmentShadingRatePropertiesKHR fsr_properties =
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008732 LvlInitStruct<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>();
8733 VkPhysicalDeviceProperties2KHR properties2 = LvlInitStruct<VkPhysicalDeviceProperties2KHR>(&fsr_properties);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008734 vkGetPhysicalDeviceProperties2KHR(gpu(), &properties2);
8735
8736 if (fsr_properties.fragmentShadingRateNonTrivialCombinerOps) {
8737 printf("%s requires fragmentShadingRateNonTrivialCombinerOps to be unsupported.\n", kSkipPrefix);
8738 return;
8739 }
8740
8741 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
8742 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
8743 ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008744 VkPhysicalDeviceFragmentShadingRateFeaturesKHR fsr_features = LvlInitStruct<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
8745 VkPhysicalDeviceFeatures2KHR features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&fsr_features);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008746 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
8747
8748 if (!fsr_features.primitiveFragmentShadingRate && !fsr_features.attachmentFragmentShadingRate) {
8749 printf("%s requires primitiveFragmentShadingRate or attachmentFragmentShadingRate to be supported.\n", kSkipPrefix);
8750 return;
8751 }
8752
8753 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
8754 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8755
8756 // Find address of extension call and make the call
8757 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR =
8758 (PFN_vkCmdSetFragmentShadingRateKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetFragmentShadingRateKHR");
8759 ASSERT_TRUE(vkCmdSetFragmentShadingRateKHR != nullptr);
8760
8761 VkExtent2D fragmentSize = {1, 1};
8762 VkFragmentShadingRateCombinerOpKHR combinerOps[2] = {VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
8763 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR};
8764
8765 m_commandBuffer->begin();
8766 if (fsr_features.primitiveFragmentShadingRate) {
8767 combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR;
8768 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8769 "VUID-vkCmdSetFragmentShadingRateKHR-fragmentSizeNonTrivialCombinerOps-04512");
8770 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8771 m_errorMonitor->VerifyFound();
8772 combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
8773 }
8774
8775 if (fsr_features.attachmentFragmentShadingRate) {
8776 combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR;
8777 m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
8778 "VUID-vkCmdSetFragmentShadingRateKHR-fragmentSizeNonTrivialCombinerOps-04512");
8779 vkCmdSetFragmentShadingRateKHR(m_commandBuffer->handle(), &fragmentSize, combinerOps);
8780 m_errorMonitor->VerifyFound();
8781 combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
8782 }
8783 m_commandBuffer->end();
8784}
8785
8786TEST_F(VkLayerTest, InvalidPrimitiveFragmentShadingRateWriteMultiViewportLimitDynamic) {
8787 TEST_DESCRIPTION("Test dynamic validation of the primitiveFragmentShadingRateWithMultipleViewports limit");
8788
8789 // Enable KHR_fragment_shading_rate and all of its required extensions
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008790 AddRequiredExtensions(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
8791 AddRequiredExtensions(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
8792 ASSERT_NO_FATAL_FAILURE(InitFramework());
8793 if (!AreRequiredExtensionsEnabled()) {
8794 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
Tobias Hector04f2ab22020-12-01 10:59:33 +00008795 }
8796
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008797 auto fsr_properties = LvlInitStruct<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>();
8798 GetPhysicalDeviceProperties2(fsr_properties);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008799
8800 if (fsr_properties.primitiveFragmentShadingRateWithMultipleViewports) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008801 GTEST_SKIP() << "Test requires primitiveFragmentShadingRateWithMultipleViewports to be unsupported.";
Tobias Hector04f2ab22020-12-01 10:59:33 +00008802 }
8803
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008804 auto eds_features = LvlInitStruct<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>();
8805 auto fsr_features = LvlInitStruct<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(&eds_features);
8806 auto features2 = GetPhysicalDeviceFeatures2(fsr_features);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008807
8808 if (!fsr_features.primitiveFragmentShadingRate) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008809 GTEST_SKIP() << "Test requires primitiveFragmentShadingRate to be supported.";
Tobias Hector04f2ab22020-12-01 10:59:33 +00008810 }
8811
8812 if (!features2.features.multiViewport) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008813 GTEST_SKIP() << "%s requires multiViewport to be supported.";
Tobias Hector04f2ab22020-12-01 10:59:33 +00008814 }
8815
8816 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
8817 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8818
sfricke-samsung1c0b96a2021-07-08 22:24:09 -07008819 char const *vsSource = R"glsl(
8820 #version 450
8821 #extension GL_EXT_fragment_shading_rate : enable
8822 void main() {
8823 gl_PrimitiveShadingRateEXT = gl_ShadingRateFlag4VerticalPixelsEXT | gl_ShadingRateFlag4HorizontalPixelsEXT;
8824 }
8825 )glsl";
Tobias Hector04f2ab22020-12-01 10:59:33 +00008826
sfricke-samsungae54c1e2022-01-21 05:35:21 -08008827 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008828
8829 VkPipelineObj pipe(m_device);
Tony-LunarG6ee10062021-02-03 13:56:52 -07008830 std::vector<VkRect2D> scissors = {{{0, 0}, {16, 16}}, {{1, 1}, {16, 16}}};
8831 pipe.SetScissor(scissors);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008832 pipe.AddShader(&fs);
8833 pipe.AddDefaultColorAttachment();
8834 pipe.MakeDynamic(VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008835 const VkPipelineLayoutObj pl(m_device);
Tony-LunarG6ee10062021-02-03 13:56:52 -07008836 {
sfricke-samsungae54c1e2022-01-21 05:35:21 -08008837 VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
Tony-LunarG6ee10062021-02-03 13:56:52 -07008838 pipe.AddShader(&vs);
8839 VkResult err = pipe.CreateVKPipeline(pl.handle(), renderPass());
8840 ASSERT_VK_SUCCESS(err);
8841 }
Tobias Hector04f2ab22020-12-01 10:59:33 +00008842 m_commandBuffer->begin();
8843 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
8844
8845 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
8846
8847 VkViewport viewports[] = {{0, 0, 16, 16, 0, 1}, {1, 1, 16, 16, 0, 1}};
8848 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT =
8849 (PFN_vkCmdSetViewportWithCountEXT)vk::GetDeviceProcAddr(device(), "vkCmdSetViewportWithCountEXT");
8850 vkCmdSetViewportWithCountEXT(m_commandBuffer->handle(), 2, viewports);
8851
8852 // error produced here.
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06008853 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552");
Tobias Hector04f2ab22020-12-01 10:59:33 +00008854 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
Tobias Hector04f2ab22020-12-01 10:59:33 +00008855 m_errorMonitor->VerifyFound();
Mark Lobodzinski07d0a612020-12-30 15:42:31 -07008856}
ziga-lunargdada63d2021-07-13 22:10:11 +02008857
8858TEST_F(VkLayerTest, InvalidCmdUpdateBufferSize) {
8859 TEST_DESCRIPTION("Update buffer with invalid dataSize");
8860
8861 ASSERT_NO_FATAL_FAILURE(Init());
8862
8863 uint32_t update_data[4] = {0, 0, 0, 0};
8864 VkDeviceSize dataSize = sizeof(uint32_t) * 4;
8865 VkMemoryPropertyFlags reqs = 0;
8866 VkBufferObj buffer;
8867 buffer.init_as_src_and_dst(*m_device, dataSize, reqs);
8868
8869 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdUpdateBuffer-dataSize-00033");
8870 m_commandBuffer->begin();
8871 vk::CmdUpdateBuffer(m_commandBuffer->handle(), buffer.handle(), sizeof(uint32_t), dataSize, (void *)update_data);
8872 m_commandBuffer->end();
8873 m_errorMonitor->VerifyFound();
8874}
ziga-lunargc08456d2021-07-16 21:40:13 +02008875
8876TEST_F(VkLayerTest, InvalidCmdUpdateBufferDstOffset) {
8877 TEST_DESCRIPTION("Update buffer with invalid dst offset");
8878
8879 ASSERT_NO_FATAL_FAILURE(Init());
8880
8881 uint32_t update_data[4] = {0, 0, 0, 0};
8882 VkDeviceSize dataSize = sizeof(uint32_t) * 4;
8883 VkMemoryPropertyFlags reqs = 0;
8884 VkBufferObj buffer;
8885 buffer.init_as_src_and_dst(*m_device, dataSize, reqs);
8886
8887 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdUpdateBuffer-dstOffset-00032");
8888 m_commandBuffer->begin();
8889 vk::CmdUpdateBuffer(m_commandBuffer->handle(), buffer.handle(), sizeof(uint32_t) * 8, dataSize, (void *)update_data);
8890 m_commandBuffer->end();
8891 m_errorMonitor->VerifyFound();
8892}
ziga-lunarg4e31a752021-07-22 14:35:03 +02008893
8894TEST_F(VkLayerTest, InvalidDescriptorSetPipelineBindPoint) {
8895 TEST_DESCRIPTION(
8896 "Attempt to bind descriptor set to a bind point not supported by command pool the command buffer was allocated from");
8897
8898 ASSERT_NO_FATAL_FAILURE(Init());
8899
8900 const uint32_t no_gfx_qfi = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT);
8901 const uint32_t INVALID_QUEUE = std::numeric_limits<uint32_t>::max();
8902 if (INVALID_QUEUE == no_gfx_qfi) {
8903 printf("%s No compute and transfer only queue family, skipping bindpoint and queue tests.\n", kSkipPrefix);
8904 return;
8905 }
8906
8907 VkCommandPoolObj command_pool(m_device, no_gfx_qfi);
8908 ASSERT_TRUE(command_pool.initialized());
8909 VkCommandBufferObj command_buffer(m_device, &command_pool);
8910
8911 VkDescriptorPoolSize ds_type_count = {};
8912 ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
8913 ds_type_count.descriptorCount = 1;
8914
8915 VkDescriptorPoolCreateInfo ds_pool_ci = LvlInitStruct<VkDescriptorPoolCreateInfo>();
8916 ds_pool_ci.maxSets = 1;
8917 ds_pool_ci.poolSizeCount = 1;
8918 ds_pool_ci.flags = 0;
8919 ds_pool_ci.pPoolSizes = &ds_type_count;
8920
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06008921 vk_testing::DescriptorPool ds_pool(*m_device, ds_pool_ci);
8922 ASSERT_TRUE(ds_pool.initialized());
ziga-lunarg4e31a752021-07-22 14:35:03 +02008923
8924 VkDescriptorSetLayoutBinding dsl_binding = {};
8925 dsl_binding.binding = 0;
8926 dsl_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
8927 dsl_binding.descriptorCount = 1;
8928 dsl_binding.stageFlags = VK_SHADER_STAGE_ALL;
8929 dsl_binding.pImmutableSamplers = nullptr;
8930
8931 const VkDescriptorSetLayoutObj ds_layout(m_device, {dsl_binding});
8932
8933 VkDescriptorSet descriptorSet;
8934 VkDescriptorSetAllocateInfo alloc_info = LvlInitStruct<VkDescriptorSetAllocateInfo>();
8935 alloc_info.descriptorSetCount = 1;
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06008936 alloc_info.descriptorPool = ds_pool.handle();
ziga-lunarg4e31a752021-07-22 14:35:03 +02008937 alloc_info.pSetLayouts = &ds_layout.handle();
8938 vk::AllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
8939
8940 const VkDescriptorSetLayoutObj descriptor_set_layout(m_device, {dsl_binding});
8941 const VkPipelineLayoutObj pipeline_layout(DeviceObj(), {&descriptor_set_layout});
8942
8943 command_buffer.begin();
8944 // Set invalid set
8945 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361");
8946 vk::CmdBindDescriptorSets(command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
8947 &descriptorSet, 0, nullptr);
8948 m_errorMonitor->VerifyFound();
8949 command_buffer.end();
8950}
ziga-lunarg4d86a252021-07-23 00:31:07 +02008951
8952TEST_F(VkLayerTest, CommandBufferMissingOcclusionQueryEnabled) {
8953 TEST_DESCRIPTION(
8954 "Test executing secondary command buffer without VkCommandBufferInheritanceInfo::occlusionQueryEnable enabled while "
8955 "occlusion query is active.");
8956 ASSERT_NO_FATAL_FAILURE(Init());
8957 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
8958
8959 VkQueryPoolCreateInfo qpci = LvlInitStruct<VkQueryPoolCreateInfo>();
8960 qpci.queryType = VK_QUERY_TYPE_OCCLUSION;
8961 qpci.queryCount = 1;
8962
8963 VkQueryPool query_pool;
8964 vk::CreateQueryPool(device(), &qpci, nullptr, &query_pool);
8965
8966 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
8967
8968 VkCommandBufferInheritanceInfo cbii = LvlInitStruct<VkCommandBufferInheritanceInfo>();
8969 cbii.renderPass = m_renderPass;
8970 cbii.framebuffer = m_framebuffer;
8971 cbii.occlusionQueryEnable = VK_FALSE; // Invalid
8972
8973 VkCommandBufferBeginInfo cbbi = LvlInitStruct<VkCommandBufferBeginInfo>();
8974 cbbi.pInheritanceInfo = &cbii;
8975
8976 VkCommandBuffer secondary_handle = secondary.handle();
8977 vk::BeginCommandBuffer(secondary_handle, &cbbi);
8978 vk::EndCommandBuffer(secondary_handle);
8979
8980 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-commandBuffer-00102");
8981 m_commandBuffer->begin();
8982 vk::CmdBeginQuery(m_commandBuffer->handle(), query_pool, 0, 0);
8983 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary_handle);
8984 vk::CmdEndQuery(m_commandBuffer->handle(), query_pool, 0);
8985 m_commandBuffer->end();
8986 m_errorMonitor->VerifyFound();
8987
8988 vk::DestroyQueryPool(device(), query_pool, nullptr);
8989}
Nathaniel Cesario46465d32021-08-03 13:52:01 -06008990
8991TEST_F(VkLayerTest, CmdClearColorImageNullColor) {
8992 TEST_DESCRIPTION("Test invalid null entries for clear color");
8993
8994 ASSERT_NO_FATAL_FAILURE(InitFramework());
8995 ASSERT_NO_FATAL_FAILURE(InitState());
8996
8997 VkImageObj image(m_device);
8998 image.Init(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
8999
9000 VkImageSubresourceRange isr = {};
9001 isr.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
9002 isr.baseArrayLayer = 0;
9003 isr.baseMipLevel = 0;
9004 isr.layerCount = 1;
9005 isr.levelCount = 1;
9006
9007 m_commandBuffer->begin();
9008 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-pColor-04961");
9009 vk::CmdClearColorImage(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, nullptr, 1, &isr);
9010 m_errorMonitor->VerifyFound();
9011 m_commandBuffer->end();
9012}
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009013
9014TEST_F(VkLayerTest, InvalidClearColorAttachmentsWithMultiview) {
9015 TEST_DESCRIPTION("Test cmdClearAttachments with active render pass that uses multiview");
9016
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009017 AddRequiredExtensions(VK_KHR_MULTIVIEW_EXTENSION_NAME);
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009018 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009019 if (!AreRequiredExtensionsEnabled()) {
9020 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009021 }
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009022
9023 auto multiview_features = LvlInitStruct<VkPhysicalDeviceMultiviewFeatures>();
9024 auto features2 = GetPhysicalDeviceFeatures2(multiview_features);
9025 if (!multiview_features.multiview) {
9026 GTEST_SKIP() << "VkPhysicalDeviceMultiviewFeatures::multiview not supported";
9027 }
9028 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009029 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
9030
9031 VkAttachmentDescription attachmentDescription = {};
9032 attachmentDescription.format = VK_FORMAT_R8G8B8A8_UNORM;
9033 attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009034 attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009035 attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
9036
9037 VkAttachmentReference colorAttachmentReference = {};
9038 colorAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
9039 colorAttachmentReference.attachment = 0;
9040
9041 VkSubpassDescription subpassDescription = {};
9042 subpassDescription.colorAttachmentCount = 1;
9043 subpassDescription.pColorAttachments = &colorAttachmentReference;
9044
9045 uint32_t viewMask = 0x1u;
9046 VkRenderPassMultiviewCreateInfo renderPassMultiviewCreateInfo = LvlInitStruct<VkRenderPassMultiviewCreateInfo>();
9047 renderPassMultiviewCreateInfo.subpassCount = 1;
9048 renderPassMultiviewCreateInfo.pViewMasks = &viewMask;
9049
9050 VkRenderPassCreateInfo renderPassCreateInfo = LvlInitStruct<VkRenderPassCreateInfo>(&renderPassMultiviewCreateInfo);
9051 renderPassCreateInfo.attachmentCount = 1;
9052 renderPassCreateInfo.pAttachments = &attachmentDescription;
9053 renderPassCreateInfo.subpassCount = 1;
9054 renderPassCreateInfo.pSubpasses = &subpassDescription;
9055
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009056 vk_testing::RenderPass renderPass(*m_device, renderPassCreateInfo);
9057 ASSERT_TRUE(renderPass.initialized());
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009058
9059 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
9060 image_create_info.imageType = VK_IMAGE_TYPE_2D;
9061 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
9062 image_create_info.extent.width = 32;
9063 image_create_info.extent.height = 32;
9064 image_create_info.extent.depth = 1;
9065 image_create_info.mipLevels = 1;
9066 image_create_info.arrayLayers = 4;
9067 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
9068 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
9069 image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
9070 image_create_info.flags = 0;
9071
9072 VkImageObj image(m_device);
9073 image.Init(image_create_info);
aitor-lunarg4c6d9b22022-01-25 20:24:57 +01009074 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,
9075 VK_REMAINING_ARRAY_LAYERS, VK_IMAGE_VIEW_TYPE_2D_ARRAY);
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009076
9077 VkFramebufferCreateInfo framebufferCreateInfo = LvlInitStruct<VkFramebufferCreateInfo>();
9078 framebufferCreateInfo.width = 32;
9079 framebufferCreateInfo.height = 32;
9080 framebufferCreateInfo.layers = 1;
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009081 framebufferCreateInfo.renderPass = renderPass.handle();
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009082 framebufferCreateInfo.attachmentCount = 1;
9083 framebufferCreateInfo.pAttachments = &imageView;
9084
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009085 vk_testing::Framebuffer framebuffer(*m_device, framebufferCreateInfo);
9086 ASSERT_TRUE(framebuffer.initialized());
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009087
9088 // Start no RenderPass
9089 m_commandBuffer->begin();
9090
9091 VkClearAttachment color_attachment;
9092 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
9093 color_attachment.clearValue.color.float32[0] = 0;
9094 color_attachment.clearValue.color.float32[1] = 0;
9095 color_attachment.clearValue.color.float32[2] = 0;
9096 color_attachment.clearValue.color.float32[3] = 0;
9097 color_attachment.colorAttachment = 0;
9098
9099 VkClearRect clear_rect = {};
9100 clear_rect.rect.extent.width = 32;
9101 clear_rect.rect.extent.height = 32;
9102
9103 VkRenderPassBeginInfo render_pass_begin_info = LvlInitStruct<VkRenderPassBeginInfo>();
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009104 render_pass_begin_info.renderPass = renderPass.handle();
9105 render_pass_begin_info.framebuffer = framebuffer.handle();
ziga-lunargad4f0fe2021-08-05 17:01:07 +02009106 render_pass_begin_info.renderArea.extent.width = 32;
9107 render_pass_begin_info.renderArea.extent.height = 32;
9108
9109 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
9110 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-baseArrayLayer-00018");
9111 clear_rect.layerCount = 2;
9112 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
9113 m_errorMonitor->VerifyFound();
9114
9115 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-baseArrayLayer-00018");
9116 clear_rect.baseArrayLayer = 1;
9117 clear_rect.layerCount = 1;
9118 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
9119 m_errorMonitor->VerifyFound();
9120}
ziga-lunargdaff74b2021-08-14 23:16:25 +02009121
9122TEST_F(VkLayerTest, TestEndCommandBufferWithConditionalRendering) {
9123 TEST_DESCRIPTION("Call EndCommandBuffer when conditional rendering is active");
9124
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009125 AddRequiredExtensions(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME);
ziga-lunargdaff74b2021-08-14 23:16:25 +02009126 ASSERT_NO_FATAL_FAILURE(InitFramework());
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009127 if (!AreRequiredExtensionsEnabled()) {
9128 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
ziga-lunargdaff74b2021-08-14 23:16:25 +02009129 }
9130 ASSERT_NO_FATAL_FAILURE(InitState());
9131
9132 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT =
9133 (PFN_vkCmdBeginConditionalRenderingEXT)vk::GetInstanceProcAddr(instance(), "vkCmdBeginConditionalRenderingEXT");
9134
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009135 auto buffer_ci =
9136 vk_testing::Buffer::create_info(32, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT);
9137 vk_testing::Buffer buffer(*m_device, buffer_ci);
ziga-lunargdaff74b2021-08-14 23:16:25 +02009138
9139 VkConditionalRenderingBeginInfoEXT conditional_rendering_begin = LvlInitStruct<VkConditionalRenderingBeginInfoEXT>();
9140 conditional_rendering_begin.buffer = buffer.handle();
9141
9142 VkCommandBufferBeginInfo command_buffer_begin = LvlInitStruct<VkCommandBufferBeginInfo>();
9143
9144 vk::BeginCommandBuffer(m_commandBuffer->handle(), &command_buffer_begin);
9145 vkCmdBeginConditionalRenderingEXT(m_commandBuffer->handle(), &conditional_rendering_begin);
9146 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkEndCommandBuffer-None-01978");
9147 vk::EndCommandBuffer(m_commandBuffer->handle());
9148 m_errorMonitor->VerifyFound();
9149}
ziga-lunarg1b7bd572021-08-21 21:49:26 +02009150
9151TEST_F(VkLayerTest, BindPipelineDuringTransformFeedback) {
9152 TEST_DESCRIPTION("Call CmdBindPipeline when transform feedback is active");
9153
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009154 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
9155 ASSERT_NO_FATAL_FAILURE(InitFramework());
9156 if (!AreRequiredExtensionsEnabled()) {
9157 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
ziga-lunarg1b7bd572021-08-21 21:49:26 +02009158 }
9159
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009160 auto xfb_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
9161 auto features2 = GetPhysicalDeviceFeatures2(xfb_features);
9162 if (!xfb_features.transformFeedback) {
9163 GTEST_SKIP() << "VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback not supported.";
9164 }
9165 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
ziga-lunarg1b7bd572021-08-21 21:49:26 +02009166 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
9167
9168 CreatePipelineHelper pipe_one(*this);
9169 pipe_one.InitInfo();
9170 pipe_one.InitState();
9171 pipe_one.CreateGraphicsPipeline();
9172
9173 CreatePipelineHelper pipe_two(*this);
9174 pipe_two.InitInfo();
9175 pipe_two.InitState();
9176 pipe_two.CreateGraphicsPipeline();
9177
9178 auto vkCmdBeginTransformFeedbackEXT =
9179 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
9180 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
9181 auto vkCmdEndTransformFeedbackEXT =
9182 (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT");
9183 ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr);
9184
9185 m_commandBuffer->begin();
9186 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe_one.pipeline_);
9187 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
9188 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindPipeline-None-02323");
9189 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe_two.pipeline_);
9190 m_errorMonitor->VerifyFound();
9191 vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
9192 m_commandBuffer->end();
ziga-lunargdeeb8252021-08-30 16:48:46 +02009193}
9194
9195TEST_F(VkLayerTest, DrawBlendEnabledFormatFeatures) {
9196 TEST_DESCRIPTION("Test pipeline blend enabled with missing image views format features");
9197
9198 ASSERT_NO_FATAL_FAILURE(Init());
9199
9200 PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr;
9201 PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr;
ziga-lunargdeeb8252021-08-30 16:48:46 +02009202 if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) {
sjfricke3a10ae82022-08-02 18:48:57 +09009203 GTEST_SKIP() << "Failed to load device profile layer.";
ziga-lunargdeeb8252021-08-30 16:48:46 +02009204 }
9205
9206 VkFormat render_format = VkTestFramework::GetFormat(instance_, m_device);
9207
9208 // Set format features from being found
9209 VkFormatProperties formatProps;
9210 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), render_format, &formatProps);
9211 if ((formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0) {
9212 printf("%s Required linear tiling features not supported.\n", kSkipPrefix);
9213 return;
9214 }
9215 // Gets pass pipeline creation but not the actual tiling used
9216 formatProps.optimalTilingFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
9217 // will be caught at draw time that feature for optimal image is not set
9218 // InitRenderTarget() should be setting color attachment as VK_IMAGE_TILING_LINEAR
9219 formatProps.linearTilingFeatures &= ~VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
9220 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), render_format, formatProps);
9221
9222 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
9223
9224 CreatePipelineHelper pipe(*this);
9225 pipe.InitInfo();
9226 pipe.InitState();
aitor-lunargf15acd52022-03-09 22:13:25 +01009227 pipe.cb_attachments_[0].blendEnable = VK_TRUE;
ziga-lunargdeeb8252021-08-30 16:48:46 +02009228 pipe.CreateGraphicsPipeline();
9229
9230 m_commandBuffer->begin();
9231 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
9232 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
9233
9234 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-blendEnable-04727");
9235 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
9236 m_errorMonitor->VerifyFound();
9237
9238 m_commandBuffer->EndRenderPass();
9239 m_commandBuffer->end();
9240}
ziga-lunarg88c0e392021-09-03 19:14:13 +02009241
9242TEST_F(VkLayerTest, InvalidEndConditionalRendering) {
9243 TEST_DESCRIPTION("Invalid calls to vkCmdEndConditionalRenderingEXT.");
9244
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009245 AddRequiredExtensions(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME);
ziga-lunarg88c0e392021-09-03 19:14:13 +02009246 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009247 if (!AreRequiredExtensionsEnabled()) {
9248 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
ziga-lunarg88c0e392021-09-03 19:14:13 +02009249 }
ziga-lunarg88c0e392021-09-03 19:14:13 +02009250 ASSERT_NO_FATAL_FAILURE(InitState());
9251
9252 VkAttachmentDescription attach[] = {
9253 {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
9254 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
9255 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
9256 };
9257 VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
9258 VkSubpassDescription subpasses[] = {
9259 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9260 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9261 };
9262
9263 VkSubpassDependency dep = {0,
9264 1,
9265 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
9266 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
9267 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
9268 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
9269 VK_DEPENDENCY_BY_REGION_BIT};
9270
9271 VkRenderPassCreateInfo rpci = LvlInitStruct<VkRenderPassCreateInfo>();
9272 rpci.attachmentCount = 1;
9273 rpci.pAttachments = attach;
9274 rpci.subpassCount = 2;
9275 rpci.pSubpasses = subpasses;
9276 rpci.dependencyCount = 1;
9277 rpci.pDependencies = &dep;
9278
9279 vk_testing::RenderPass render_pass;
9280 render_pass.init(*m_device, rpci);
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009281 ASSERT_TRUE(render_pass.initialized());
ziga-lunarg88c0e392021-09-03 19:14:13 +02009282
9283 VkImageObj image(m_device);
9284 image.InitNoLayout(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
9285 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
9286
9287 VkFramebufferCreateInfo fbci = LvlInitStruct<VkFramebufferCreateInfo>();
9288 fbci.renderPass = render_pass.handle();
9289 fbci.attachmentCount = 1;
9290 fbci.pAttachments = &imageView;
9291 fbci.width = 32;
9292 fbci.height = 32;
9293 fbci.layers = 1;
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009294 vk_testing::Framebuffer framebuffer(*m_device, fbci);
9295 ASSERT_TRUE(framebuffer.initialized());
ziga-lunarg88c0e392021-09-03 19:14:13 +02009296
9297 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT =
9298 (PFN_vkCmdBeginConditionalRenderingEXT)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdBeginConditionalRenderingEXT");
9299 PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT =
9300 (PFN_vkCmdEndConditionalRenderingEXT)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdEndConditionalRenderingEXT");
9301
9302 VkBufferCreateInfo buffer_create_info = LvlInitStruct<VkBufferCreateInfo>();
9303 buffer_create_info.size = 32;
9304 buffer_create_info.usage = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT;
9305 VkBufferObj buffer;
9306 buffer.init(*m_device, buffer_create_info);
9307
9308 VkConditionalRenderingBeginInfoEXT conditional_rendering_begin = LvlInitStruct<VkConditionalRenderingBeginInfoEXT>();
9309 conditional_rendering_begin.buffer = buffer.handle();
9310
9311 VkClearValue clear_value;
9312 clear_value.color = m_clear_color;
9313
9314 VkRenderPassBeginInfo rpbi = LvlInitStruct<VkRenderPassBeginInfo>();
9315 rpbi.renderPass = render_pass.handle();
Nathaniel Cesario079b1b92022-07-06 15:56:26 -06009316 rpbi.framebuffer = framebuffer.handle();
ziga-lunarg88c0e392021-09-03 19:14:13 +02009317 rpbi.renderArea = {{0, 0}, {32, 32}};
9318 rpbi.clearValueCount = 1;
9319 rpbi.pClearValues = &clear_value;
9320
9321 m_commandBuffer->begin();
9322
9323 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndConditionalRenderingEXT-None-01985");
9324 vkCmdEndConditionalRenderingEXT(m_commandBuffer->handle());
9325 m_errorMonitor->VerifyFound();
9326
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009327 vkCmdBeginConditionalRenderingEXT(m_commandBuffer->handle(), &conditional_rendering_begin);
9328 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
ziga-lunarg88c0e392021-09-03 19:14:13 +02009329 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndConditionalRenderingEXT-None-01986");
ziga-lunarg88c0e392021-09-03 19:14:13 +02009330 vkCmdEndConditionalRenderingEXT(m_commandBuffer->handle());
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009331 m_errorMonitor->VerifyFound();
ziga-lunarg88c0e392021-09-03 19:14:13 +02009332 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
9333 vk::CmdEndRenderPass(m_commandBuffer->handle());
9334 vkCmdEndConditionalRenderingEXT(m_commandBuffer->handle());
ziga-lunarg88c0e392021-09-03 19:14:13 +02009335
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009336 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
9337 vkCmdBeginConditionalRenderingEXT(m_commandBuffer->handle(), &conditional_rendering_begin);
9338 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
ziga-lunarg88c0e392021-09-03 19:14:13 +02009339 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndConditionalRenderingEXT-None-01987");
ziga-lunarg88c0e392021-09-03 19:14:13 +02009340 vkCmdEndConditionalRenderingEXT(m_commandBuffer->handle());
ziga-lunarg88c0e392021-09-03 19:14:13 +02009341 m_errorMonitor->VerifyFound();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009342 vk::CmdEndRenderPass(m_commandBuffer->handle());
ziga-lunarg88c0e392021-09-03 19:14:13 +02009343}
ziga-lunarg58255142021-09-12 13:25:17 +02009344
9345TEST_F(VkLayerTest, InvalidBeginTransformFeedbackInMultiviewRenderPass) {
9346 TEST_DESCRIPTION("Test beginning transform feedback in a render pass with multiview enabled");
9347
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009348 AddRequiredExtensions(VK_KHR_MULTIVIEW_EXTENSION_NAME);
9349 AddRequiredExtensions(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
ziga-lunarg58255142021-09-12 13:25:17 +02009350 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009351 if (!AreRequiredExtensionsEnabled()) {
9352 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported.";
ziga-lunarg58255142021-09-12 13:25:17 +02009353 }
ziga-lunarg58255142021-09-12 13:25:17 +02009354
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009355 auto mv_features = LvlInitStruct<VkPhysicalDeviceMultiviewFeaturesKHR>();
9356 auto tf_features = LvlInitStruct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(&mv_features);
9357 auto pd_features = GetPhysicalDeviceFeatures2(tf_features);
ziga-lunarg58255142021-09-12 13:25:17 +02009358
9359 if (!tf_features.transformFeedback) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009360 GTEST_SKIP() << "transformFeedback not supported; skipped.";
9361 }
9362 if (!mv_features.multiview) {
9363 GTEST_SKIP() << "multiview not supported.";
ziga-lunarg58255142021-09-12 13:25:17 +02009364 }
9365
9366 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features));
9367 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
9368
9369 VkAttachmentDescription attachmentDescription = {};
9370 attachmentDescription.format = VK_FORMAT_R8G8B8A8_UNORM;
9371 attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009372 attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
ziga-lunarg58255142021-09-12 13:25:17 +02009373 attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
9374
9375 VkAttachmentReference colorAttachmentReference = {};
9376 colorAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
9377 colorAttachmentReference.attachment = 0;
9378
9379 VkSubpassDescription subpassDescription = {};
9380 subpassDescription.colorAttachmentCount = 1;
9381 subpassDescription.pColorAttachments = &colorAttachmentReference;
9382
9383 uint32_t viewMask = 0x1u;
9384 VkRenderPassMultiviewCreateInfo renderPassMultiviewCreateInfo = LvlInitStruct<VkRenderPassMultiviewCreateInfo>();
9385 renderPassMultiviewCreateInfo.subpassCount = 1;
9386 renderPassMultiviewCreateInfo.pViewMasks = &viewMask;
9387
9388 VkRenderPassCreateInfo renderPassCreateInfo = LvlInitStruct<VkRenderPassCreateInfo>(&renderPassMultiviewCreateInfo);
9389 renderPassCreateInfo.attachmentCount = 1;
9390 renderPassCreateInfo.pAttachments = &attachmentDescription;
9391 renderPassCreateInfo.subpassCount = 1;
9392 renderPassCreateInfo.pSubpasses = &subpassDescription;
9393
9394 vk_testing::RenderPass render_pass;
9395 render_pass.init(*m_device, renderPassCreateInfo);
9396
9397 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
9398 image_create_info.imageType = VK_IMAGE_TYPE_2D;
9399 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
9400 image_create_info.extent.width = 32;
9401 image_create_info.extent.height = 32;
9402 image_create_info.extent.depth = 1;
9403 image_create_info.mipLevels = 1;
9404 image_create_info.arrayLayers = 4;
9405 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
9406 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
9407 image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
9408 image_create_info.flags = 0;
9409
9410 VkImageObj image(m_device);
9411 image.Init(image_create_info);
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009412 auto image_view_ci = image.TargetViewCI(VK_FORMAT_R8G8B8A8_UNORM);
9413 image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
9414 VkImageView imageView = image.targetView(image_view_ci);
ziga-lunarg58255142021-09-12 13:25:17 +02009415
9416 VkFramebufferCreateInfo framebufferCreateInfo = LvlInitStruct<VkFramebufferCreateInfo>();
9417 framebufferCreateInfo.width = 32;
9418 framebufferCreateInfo.height = 32;
9419 framebufferCreateInfo.layers = 1;
9420 framebufferCreateInfo.renderPass = render_pass.handle();
9421 framebufferCreateInfo.attachmentCount = 1;
9422 framebufferCreateInfo.pAttachments = &imageView;
9423
9424 vk_testing::Framebuffer framebuffer;
9425 framebuffer.init(*m_device, framebufferCreateInfo);
9426
9427 VkRenderPassBeginInfo render_pass_begin_info = LvlInitStruct<VkRenderPassBeginInfo>();
9428 render_pass_begin_info.renderPass = render_pass.handle();
9429 render_pass_begin_info.framebuffer = framebuffer.handle();
9430 render_pass_begin_info.renderArea.extent.width = 32;
9431 render_pass_begin_info.renderArea.extent.height = 32;
9432
9433 auto vkCmdBeginTransformFeedbackEXT =
9434 (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT");
9435 ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr);
9436
9437 m_commandBuffer->begin();
9438 m_commandBuffer->BeginRenderPass(render_pass_begin_info);
9439
9440 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-None-02373");
9441 vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr);
9442 m_errorMonitor->VerifyFound();
9443
9444 m_commandBuffer->EndRenderPass();
9445 m_commandBuffer->end();
9446}
stusmithd2f36832021-11-26 11:44:11 +00009447
9448TEST_F(VkLayerTest, BeginRenderingWithSecondaryContents) {
9449 TEST_DESCRIPTION("Test that an error is produced when a secondary command buffer calls BeginRendering with secondary contents");
9450
9451 SetTargetApiVersion(VK_API_VERSION_1_1);
9452
stusmithab8e2a22021-12-17 11:20:03 +00009453 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
9454
stusmithd2f36832021-11-26 11:44:11 +00009455 ASSERT_NO_FATAL_FAILURE(InitFramework());
9456
sjfricked700bc02022-05-30 16:35:06 +09009457 if (!AreRequiredExtensionsEnabled()) {
9458 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +00009459 }
9460
9461 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09009462 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +00009463 }
9464
9465 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
9466 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
9467 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
9468 if (!dynamic_rendering_features.dynamicRendering) {
9469 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
9470 return;
9471 }
9472
9473 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
9474
sfricke-samsung1c61f192021-12-31 01:53:03 -06009475 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009476 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
9477
sfricke-samsung1c61f192021-12-31 01:53:03 -06009478 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009479 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
ziga-lunargaa97cbb2022-03-18 19:06:35 +01009480 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +00009481 begin_rendering_info.colorAttachmentCount = 1;
9482 begin_rendering_info.pColorAttachments = &color_attachment;
9483
9484 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9485
9486 secondary.begin();
9487
Tony-LunarGbbd2ab92021-12-02 08:31:24 -07009488 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginRendering-commandBuffer-06068");
stusmithd2f36832021-11-26 11:44:11 +00009489 secondary.BeginRendering(begin_rendering_info);
9490 m_errorMonitor->VerifyFound();
9491
9492 secondary.end();
9493}
9494
9495TEST_F(VkLayerTest, BadRenderPassContentsWhenCallingCmdExecuteCommandsWithBeginRenderPass) {
9496 TEST_DESCRIPTION(
9497 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRenderPass that hasn't set "
9498 "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS");
9499
9500 ASSERT_NO_FATAL_FAILURE(Init());
9501 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
9502
9503 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9504
9505 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9506 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9507 nullptr, // pNext
9508 m_renderPass,
9509 0, // subpass
9510 m_framebuffer,
9511 };
9512
9513 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9514 nullptr, // pNext
9515 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9516 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9517 secondary.begin(&cmdbuff__bi);
9518 secondary.end();
9519
9520 m_commandBuffer->begin();
9521
9522 const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
9523 nullptr, // pNext
9524 m_renderPass,
9525 m_framebuffer,
9526 {{0, 0}, {32, 32}},
9527 static_cast<uint32_t>(m_renderPassClearValues.size()),
9528 m_renderPassClearValues.data()};
9529
9530 m_commandBuffer->BeginRenderPass(rp_bi);
9531
9532 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-contents-06018");
ziga-lunarga3cc8482022-04-29 14:58:29 +02009533 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-contents-00095");
stusmithd2f36832021-11-26 11:44:11 +00009534 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9535 m_errorMonitor->VerifyFound();
9536
9537 m_commandBuffer->EndRenderPass();
9538 m_commandBuffer->end();
9539}
9540
9541TEST_F(VkLayerTest, BadRenderPassContentsWhenCallingCmdExecuteCommandsWithBeginRendering) {
9542 TEST_DESCRIPTION(
9543 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that hasn't set "
9544 "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR");
9545
9546 SetTargetApiVersion(VK_API_VERSION_1_1);
sfricke-samsung1c61f192021-12-31 01:53:03 -06009547
stusmithab8e2a22021-12-17 11:20:03 +00009548 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
9549
stusmithd2f36832021-11-26 11:44:11 +00009550 ASSERT_NO_FATAL_FAILURE(InitFramework());
stusmithab8e2a22021-12-17 11:20:03 +00009551
sjfricked700bc02022-05-30 16:35:06 +09009552 if (!AreRequiredExtensionsEnabled()) {
9553 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithd2f36832021-11-26 11:44:11 +00009554 }
stusmithab8e2a22021-12-17 11:20:03 +00009555
9556 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09009557 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithab8e2a22021-12-17 11:20:03 +00009558 }
9559
stusmithd2f36832021-11-26 11:44:11 +00009560 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
9561 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
9562 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
9563 if (!dynamic_rendering_features.dynamicRendering) {
9564 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
9565 return;
9566 }
sfricke-samsung1c61f192021-12-31 01:53:03 -06009567
stusmithd2f36832021-11-26 11:44:11 +00009568 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
9569
9570 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
sfricke-samsung1c61f192021-12-31 01:53:03 -06009571
9572 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009573 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
9574
sfricke-samsung1c61f192021-12-31 01:53:03 -06009575 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
9576 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009577 inheritance_rendering_info.colorAttachmentCount = 1;
9578 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
stusmithcba0c502021-12-21 17:16:28 +00009579 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +00009580
sfricke-samsung1c61f192021-12-31 01:53:03 -06009581 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009582 begin_rendering_info.colorAttachmentCount = 1;
9583 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009584 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +00009585
9586 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9587
9588 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9589 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9590 &inheritance_rendering_info, // pNext
9591 VK_NULL_HANDLE,
9592 0, // subpass
9593 VK_NULL_HANDLE,
9594 };
9595
9596 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9597 nullptr, // pNext
9598 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9599 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9600 secondary.begin(&cmdbuff__bi);
9601 secondary.end();
9602
9603 m_commandBuffer->begin();
9604
9605 m_commandBuffer->BeginRendering(begin_rendering_info);
9606
9607 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-flags-06024");
9608 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9609 m_errorMonitor->VerifyFound();
9610
9611 m_commandBuffer->EndRendering();
9612 m_commandBuffer->end();
9613}
9614
9615TEST_F(VkLayerTest, BadExecuteCommandsSubpassIndices) {
9616 TEST_DESCRIPTION("Test invalid subpass when calling CmdExecuteCommands");
9617
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009618 ASSERT_NO_FATAL_FAILURE(InitFramework());
stusmithd2f36832021-11-26 11:44:11 +00009619 ASSERT_NO_FATAL_FAILURE(InitState());
9620
9621 // A renderpass with two subpasses, both writing the same attachment.
9622 VkAttachmentDescription attach[] = {
9623 {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
9624 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
9625 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
9626 };
9627 VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
9628 VkSubpassDescription subpasses[] = {
9629 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9630 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9631 };
9632
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009633 VkSubpassDependency dependencies = {
9634 0, // srcSubpass
9635 1, // dstSubpass
9636 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // srcStageMask
9637 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // dstStageMask
9638 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // srcAccessMask
9639 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // dstAccessMask
9640 0, // dependencyFlags
9641 };
9642
9643 auto rpci = LvlInitStruct<VkRenderPassCreateInfo>();
9644 rpci.attachmentCount = 1;
9645 rpci.pAttachments = attach;
9646 rpci.subpassCount = 2;
9647 rpci.pSubpasses = subpasses;
9648 rpci.dependencyCount = 1;
9649 rpci.pDependencies = &dependencies;
9650 vk_testing::RenderPass render_pass(*m_device, rpci);
9651 ASSERT_TRUE(render_pass.initialized());
stusmithd2f36832021-11-26 11:44:11 +00009652
9653 VkImageObj image(m_device);
9654 image.InitNoLayout(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
9655 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
9656
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009657 VkFramebufferCreateInfo fbci = {
9658 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, render_pass.handle(), 1, &imageView, 32, 32, 1};
9659 vk_testing::Framebuffer framebuffer(*m_device, fbci);
9660 ASSERT_TRUE(framebuffer.initialized());
stusmithd2f36832021-11-26 11:44:11 +00009661
9662 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9663
9664 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9665 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9666 nullptr, // pNext
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009667 render_pass.handle(),
stusmithd2f36832021-11-26 11:44:11 +00009668 1, // subpass
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009669 framebuffer.handle(),
stusmithd2f36832021-11-26 11:44:11 +00009670 };
9671
9672 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9673 nullptr, // pNext
9674 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9675 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9676 secondary.begin(&cmdbuff__bi);
9677 secondary.end();
9678
9679 const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
9680 nullptr, // pNext
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009681 render_pass.handle(),
9682 framebuffer.handle(),
stusmithd2f36832021-11-26 11:44:11 +00009683 {{0, 0}, {32, 32}},
9684 0,
9685 nullptr};
9686
9687 m_commandBuffer->begin();
9688 m_commandBuffer->BeginRenderPass(rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
9689
9690 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-06019");
ziga-lunarga3cc8482022-04-29 14:58:29 +02009691 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00097");
stusmithd2f36832021-11-26 11:44:11 +00009692 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9693 m_errorMonitor->VerifyFound();
stusmithd2f36832021-11-26 11:44:11 +00009694}
9695
9696TEST_F(VkLayerTest, IncompatibleRenderPassesInExecuteCommands) {
9697 TEST_DESCRIPTION("Test invalid subpass when calling CmdExecuteCommands");
9698
9699 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
9700 ASSERT_NO_FATAL_FAILURE(InitState());
9701
9702 // A renderpass with two subpasses, both writing the same attachment.
9703 VkAttachmentDescription attach[] = {
9704 {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
9705 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
9706 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
9707 };
9708 VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
9709 VkSubpassDescription subpasses[] = {
9710 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9711 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9712 };
9713
9714 VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 1, subpasses, 0, nullptr};
9715 VkRenderPass render_pass_1;
9716 VkResult err = vk::CreateRenderPass(m_device->device(), &rpci, nullptr, &render_pass_1);
9717 ASSERT_VK_SUCCESS(err);
9718
9719 VkRenderPassCreateInfo rpci_2 = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 2, subpasses, 0, nullptr};
9720 VkRenderPass render_pass_2;
9721 vk::CreateRenderPass(m_device->device(), &rpci_2, nullptr, &render_pass_2);
9722 ASSERT_VK_SUCCESS(err);
9723
9724 VkImageObj image(m_device);
9725 image.InitNoLayout(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
9726 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
9727
9728 VkFramebufferCreateInfo fbci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, render_pass_1, 1, &imageView, 32, 32, 1};
9729 VkFramebuffer framebuffer;
9730 err = vk::CreateFramebuffer(m_device->device(), &fbci, nullptr, &framebuffer);
9731 ASSERT_VK_SUCCESS(err);
9732
9733 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9734
9735 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9736 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9737 nullptr, // pNext
9738 render_pass_2,
9739 0, // subpass
9740 VK_NULL_HANDLE,
9741 };
9742
9743 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9744 nullptr, // pNext
9745 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9746 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9747 secondary.begin(&cmdbuff__bi);
9748 secondary.end();
9749
9750 const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
9751 nullptr, // pNext
9752 render_pass_1,
9753 framebuffer,
9754 {{0, 0}, {32, 32}},
9755 0,
9756 nullptr};
9757
9758 m_commandBuffer->begin();
9759 m_commandBuffer->BeginRenderPass(rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
9760
9761 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pBeginInfo-06020");
ziga-lunarga3cc8482022-04-29 14:58:29 +02009762 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pInheritanceInfo-00098");
stusmithd2f36832021-11-26 11:44:11 +00009763 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9764 m_errorMonitor->VerifyFound();
9765
9766 m_commandBuffer->EndRenderPass();
9767 m_commandBuffer->end();
9768
9769 vk::DestroyFramebuffer(m_device->device(), framebuffer, nullptr);
9770 vk::DestroyRenderPass(m_device->device(), render_pass_2, nullptr);
9771 vk::DestroyRenderPass(m_device->device(), render_pass_1, nullptr);
9772}
9773
9774TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithNonNullRenderPass) {
9775 TEST_DESCRIPTION(
9776 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that hasn't set "
9777 "renderPass to VK_NULL_HANDLE in pInheritanceInfo");
9778
9779 SetTargetApiVersion(VK_API_VERSION_1_1);
sfricke-samsung1c61f192021-12-31 01:53:03 -06009780
stusmithab8e2a22021-12-17 11:20:03 +00009781 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
9782
stusmithd2f36832021-11-26 11:44:11 +00009783 ASSERT_NO_FATAL_FAILURE(InitFramework());
stusmithab8e2a22021-12-17 11:20:03 +00009784
sjfricked700bc02022-05-30 16:35:06 +09009785 if (!AreRequiredExtensionsEnabled()) {
9786 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithd2f36832021-11-26 11:44:11 +00009787 }
stusmithab8e2a22021-12-17 11:20:03 +00009788
9789 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09009790 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithab8e2a22021-12-17 11:20:03 +00009791 }
9792
stusmithd2f36832021-11-26 11:44:11 +00009793 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
9794 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
9795 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
9796 if (!dynamic_rendering_features.dynamicRendering) {
9797 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
9798 return;
9799 }
sfricke-samsung1c61f192021-12-31 01:53:03 -06009800
stusmithd2f36832021-11-26 11:44:11 +00009801 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
9802
9803 VkAttachmentDescription attach[] = {
9804 {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
9805 VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
9806 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
9807 };
9808 VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
9809 VkSubpassDescription subpasses[] = {
9810 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9811 {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
9812 };
9813
9814 VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 2, subpasses, 0, nullptr};
9815 VkRenderPass render_pass;
9816 VkResult err = vk::CreateRenderPass(m_device->device(), &rpci, nullptr, &render_pass);
9817 ASSERT_VK_SUCCESS(err);
9818
9819 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
sfricke-samsung1c61f192021-12-31 01:53:03 -06009820
9821 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009822 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
9823
sfricke-samsung1c61f192021-12-31 01:53:03 -06009824 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
9825 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009826 inheritance_rendering_info.colorAttachmentCount = 1;
9827 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
stusmithcba0c502021-12-21 17:16:28 +00009828 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +00009829
sfricke-samsung1c61f192021-12-31 01:53:03 -06009830 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009831 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
9832 begin_rendering_info.colorAttachmentCount = 1;
9833 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009834 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +00009835
9836 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9837
9838 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9839 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9840 &inheritance_rendering_info, // pNext
9841 render_pass,
9842 0, // subpass
9843 VK_NULL_HANDLE,
9844 };
9845
9846 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9847 nullptr, // pNext
9848 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9849 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9850 secondary.begin(&cmdbuff__bi);
9851 secondary.end();
9852
9853 m_commandBuffer->begin();
9854
9855 m_commandBuffer->BeginRendering(begin_rendering_info);
9856
9857 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pBeginInfo-06025");
9858 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9859 m_errorMonitor->VerifyFound();
9860
9861 m_commandBuffer->EndRendering();
9862 m_commandBuffer->end();
9863
9864 vk::DestroyRenderPass(m_device->device(), render_pass, nullptr);
9865}
9866
9867TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingFlags) {
9868 TEST_DESCRIPTION("Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching flags");
9869
9870 SetTargetApiVersion(VK_API_VERSION_1_1);
9871
stusmithab8e2a22021-12-17 11:20:03 +00009872 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
9873
stusmithd2f36832021-11-26 11:44:11 +00009874 ASSERT_NO_FATAL_FAILURE(InitFramework());
9875
sjfricked700bc02022-05-30 16:35:06 +09009876 if (!AreRequiredExtensionsEnabled()) {
9877 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +00009878 }
9879
9880 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09009881 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +00009882 }
9883
9884 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
9885 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
9886 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
9887 if (!dynamic_rendering_features.dynamicRendering) {
9888 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
9889 return;
9890 }
9891
9892 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
9893
9894 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
9895
sfricke-samsung1c61f192021-12-31 01:53:03 -06009896 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009897 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
9898
sfricke-samsung1c61f192021-12-31 01:53:03 -06009899 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
9900 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009901 inheritance_rendering_info.colorAttachmentCount = 1;
9902 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
stusmithcba0c502021-12-21 17:16:28 +00009903 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +00009904
sfricke-samsung1c61f192021-12-31 01:53:03 -06009905 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009906 begin_rendering_info.flags =
9907 VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR | VK_RENDERING_SUSPENDING_BIT_KHR | VK_RENDERING_RESUMING_BIT_KHR;
9908 begin_rendering_info.colorAttachmentCount = 1;
9909 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009910 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +00009911
9912 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9913
9914 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9915 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9916 &inheritance_rendering_info, // pNext
9917 VK_NULL_HANDLE,
9918 0, // subpass
9919 VK_NULL_HANDLE,
9920 };
9921
9922 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9923 nullptr, // pNext
9924 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9925 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
9926 secondary.begin(&cmdbuff__bi);
9927 secondary.end();
9928
9929 m_commandBuffer->begin();
9930
9931 m_commandBuffer->BeginRendering(begin_rendering_info);
9932
9933 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-flags-06026");
9934 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
9935 m_errorMonitor->VerifyFound();
9936
9937 m_commandBuffer->EndRendering();
9938 m_commandBuffer->end();
9939}
9940
9941TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingColorAttachmentCount) {
9942 TEST_DESCRIPTION(
9943 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching colorAttachmentCount");
9944
9945 SetTargetApiVersion(VK_API_VERSION_1_1);
9946
stusmithab8e2a22021-12-17 11:20:03 +00009947 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
9948
stusmithd2f36832021-11-26 11:44:11 +00009949 ASSERT_NO_FATAL_FAILURE(InitFramework());
9950
sjfricked700bc02022-05-30 16:35:06 +09009951 if (!AreRequiredExtensionsEnabled()) {
9952 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +00009953 }
9954
9955 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +09009956 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +00009957 }
9958
9959 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
9960 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
9961 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
9962 if (!dynamic_rendering_features.dynamicRendering) {
9963 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
9964 return;
9965 }
9966
9967 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
9968
9969 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
9970
sfricke-samsung1c61f192021-12-31 01:53:03 -06009971 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009972 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
9973
sfricke-samsung1c61f192021-12-31 01:53:03 -06009974 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
9975 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009976 inheritance_rendering_info.colorAttachmentCount = 0;
9977 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
stusmithcba0c502021-12-21 17:16:28 +00009978 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +00009979
sfricke-samsung1c61f192021-12-31 01:53:03 -06009980 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +00009981 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
9982 begin_rendering_info.colorAttachmentCount = 1;
9983 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -06009984 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +00009985
9986 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
9987
9988 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
9989 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
9990 &inheritance_rendering_info, // pNext
9991 VK_NULL_HANDLE,
9992 0, // subpass
9993 VK_NULL_HANDLE,
9994 };
9995
9996 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
9997 nullptr, // pNext
9998 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
9999 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10000 secondary.begin(&cmdbuff__bi);
10001 secondary.end();
10002
10003 m_commandBuffer->begin();
10004
10005 m_commandBuffer->BeginRendering(begin_rendering_info);
10006
10007 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-colorAttachmentCount-06027");
10008 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10009 m_errorMonitor->VerifyFound();
10010
10011 m_commandBuffer->EndRendering();
10012 m_commandBuffer->end();
10013}
10014
10015TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingColorImageViewFormat) {
10016 TEST_DESCRIPTION(
10017 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching color image view format");
10018
10019 SetTargetApiVersion(VK_API_VERSION_1_1);
10020
stusmithab8e2a22021-12-17 11:20:03 +000010021 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
10022
stusmithd2f36832021-11-26 11:44:11 +000010023 ASSERT_NO_FATAL_FAILURE(InitFramework());
10024
sjfricked700bc02022-05-30 16:35:06 +090010025 if (!AreRequiredExtensionsEnabled()) {
10026 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +000010027 }
10028
10029 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010030 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +000010031 }
10032
10033 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
10034 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
10035 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
10036 if (!dynamic_rendering_features.dynamicRendering) {
10037 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
10038 return;
10039 }
10040
10041 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
10042
10043 VkImageObj image(m_device);
10044 image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
10045 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
10046
sfricke-samsung1c61f192021-12-31 01:53:03 -060010047 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010048 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
10049 color_attachment.imageView = imageView;
10050
10051 VkFormat bad_color_formats = {VK_FORMAT_R8G8B8A8_UINT};
10052
sfricke-samsung1c61f192021-12-31 01:53:03 -060010053 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
10054 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010055 inheritance_rendering_info.colorAttachmentCount = 1;
10056 inheritance_rendering_info.pColorAttachmentFormats = &bad_color_formats;
stusmithcba0c502021-12-21 17:16:28 +000010057 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +000010058
sfricke-samsung1c61f192021-12-31 01:53:03 -060010059 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010060 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
10061 begin_rendering_info.colorAttachmentCount = 1;
10062 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010063 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +000010064
10065 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
10066
10067 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
10068 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
10069 &inheritance_rendering_info, // pNext
10070 VK_NULL_HANDLE,
10071 0, // subpass
10072 VK_NULL_HANDLE,
10073 };
10074
10075 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
10076 nullptr, // pNext
10077 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
10078 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10079 secondary.begin(&cmdbuff__bi);
10080 secondary.end();
10081
10082 m_commandBuffer->begin();
10083
10084 m_commandBuffer->BeginRendering(begin_rendering_info);
10085
10086 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-imageView-06028");
10087 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10088 m_errorMonitor->VerifyFound();
10089
10090 m_commandBuffer->EndRendering();
10091 m_commandBuffer->end();
10092}
10093
10094TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingDepthStencilImageViewFormat) {
10095 TEST_DESCRIPTION(
10096 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching depth/stencil image view "
10097 "format");
10098
10099 SetTargetApiVersion(VK_API_VERSION_1_1);
10100
stusmithab8e2a22021-12-17 11:20:03 +000010101 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
10102
stusmithd2f36832021-11-26 11:44:11 +000010103 ASSERT_NO_FATAL_FAILURE(InitFramework());
10104
sjfricked700bc02022-05-30 16:35:06 +090010105 if (!AreRequiredExtensionsEnabled()) {
10106 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +000010107 }
10108
10109 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010110 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +000010111 }
10112
10113 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
10114 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
10115 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
10116 if (!dynamic_rendering_features.dynamicRendering) {
10117 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
10118 return;
10119 }
10120
10121 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
10122
10123 VkImageObj image(m_device);
10124 auto depth_stencil_format = FindSupportedDepthStencilFormat(gpu());
10125 if (!depth_stencil_format) {
10126 printf("%s Couldn't depth stencil image format.\n", kSkipPrefix);
10127 return;
10128 }
10129 image.Init(32, 32, 1, depth_stencil_format, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
10130 VkImageView imageView = image.targetView(depth_stencil_format, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT);
10131
sfricke-samsung1c61f192021-12-31 01:53:03 -060010132 VkRenderingAttachmentInfoKHR depth_stencil_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010133 depth_stencil_attachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
10134 depth_stencil_attachment.imageView = imageView;
10135
sfricke-samsung1c61f192021-12-31 01:53:03 -060010136 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
10137 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010138 inheritance_rendering_info.depthAttachmentFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
10139 inheritance_rendering_info.stencilAttachmentFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
stusmithcba0c502021-12-21 17:16:28 +000010140 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +000010141
sfricke-samsung1c61f192021-12-31 01:53:03 -060010142 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010143 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
10144 begin_rendering_info.pDepthAttachment = &depth_stencil_attachment;
10145 begin_rendering_info.pStencilAttachment = &depth_stencil_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010146 begin_rendering_info.layerCount = 1;
stusmithd2f36832021-11-26 11:44:11 +000010147
10148 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
10149
10150 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
10151 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
10152 &inheritance_rendering_info, // pNext
10153 VK_NULL_HANDLE,
10154 0, // subpass
10155 VK_NULL_HANDLE,
10156 };
10157
10158 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
10159 nullptr, // pNext
10160 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
10161 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10162 secondary.begin(&cmdbuff__bi);
10163 secondary.end();
10164
10165 m_commandBuffer->begin();
10166
10167 m_commandBuffer->BeginRendering(begin_rendering_info);
10168
10169 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pDepthAttachment-06029");
10170 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pStencilAttachment-06030");
10171 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10172 m_errorMonitor->VerifyFound();
stusmithd2f36832021-11-26 11:44:11 +000010173}
10174
10175TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingViewMask) {
10176 TEST_DESCRIPTION(
10177 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching viewMask format");
10178
10179 SetTargetApiVersion(VK_API_VERSION_1_1);
10180
stusmithab8e2a22021-12-17 11:20:03 +000010181 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
10182
stusmithd2f36832021-11-26 11:44:11 +000010183 ASSERT_NO_FATAL_FAILURE(InitFramework());
10184
sjfricked700bc02022-05-30 16:35:06 +090010185 if (!AreRequiredExtensionsEnabled()) {
10186 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithab8e2a22021-12-17 11:20:03 +000010187 }
10188
10189 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010190 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithd2f36832021-11-26 11:44:11 +000010191 }
10192
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010193 auto mv_features = LvlInitStruct<VkPhysicalDeviceMultiviewFeaturesKHR>();
10194 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>(&mv_features);
10195 auto features2 = GetPhysicalDeviceFeatures2(dynamic_rendering_features);
stusmithd2f36832021-11-26 11:44:11 +000010196 if (!dynamic_rendering_features.dynamicRendering) {
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010197 GTEST_SKIP() << "Test requires (unsupported) dynamicRendering , skipping.";
10198 }
10199 if (!mv_features.multiview) {
10200 GTEST_SKIP() << "multiview feature not supported.";
stusmithd2f36832021-11-26 11:44:11 +000010201 }
10202
10203 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
10204
sfricke-samsung1c61f192021-12-31 01:53:03 -060010205 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010206 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
10207
10208 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
10209
sfricke-samsung1c61f192021-12-31 01:53:03 -060010210 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
10211 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010212 inheritance_rendering_info.viewMask = 0;
10213 inheritance_rendering_info.colorAttachmentCount = 1;
10214 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
stusmithcba0c502021-12-21 17:16:28 +000010215 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
stusmithd2f36832021-11-26 11:44:11 +000010216
sfricke-samsung1c61f192021-12-31 01:53:03 -060010217 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithd2f36832021-11-26 11:44:11 +000010218 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
10219 begin_rendering_info.viewMask = 1;
10220 begin_rendering_info.colorAttachmentCount = 1;
10221 begin_rendering_info.pColorAttachments = &color_attachment;
10222
10223 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
10224
10225 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
10226 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
10227 &inheritance_rendering_info, // pNext
10228 VK_NULL_HANDLE,
10229 0, // subpass
10230 VK_NULL_HANDLE,
10231 };
10232
10233 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
10234 nullptr, // pNext
10235 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
10236 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10237 secondary.begin(&cmdbuff__bi);
10238 secondary.end();
10239
10240 m_commandBuffer->begin();
10241
10242 m_commandBuffer->BeginRendering(begin_rendering_info);
10243
10244 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-viewMask-06031");
10245 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10246 m_errorMonitor->VerifyFound();
stusmithd2f36832021-11-26 11:44:11 +000010247}
stusmithcba0c502021-12-21 17:16:28 +000010248
10249TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingImageViewRasterizationSamples) {
10250 TEST_DESCRIPTION(
10251 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching rasterization samples");
10252
10253 SetTargetApiVersion(VK_API_VERSION_1_1);
10254
10255 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
10256
10257 ASSERT_NO_FATAL_FAILURE(InitFramework());
10258
sjfricked700bc02022-05-30 16:35:06 +090010259 if (!AreRequiredExtensionsEnabled()) {
10260 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithcba0c502021-12-21 17:16:28 +000010261 }
10262
10263 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010264 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithcba0c502021-12-21 17:16:28 +000010265 }
10266
10267 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
10268 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
10269 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
10270 if (!dynamic_rendering_features.dynamicRendering) {
10271 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
10272 return;
10273 }
10274
10275 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
10276
10277 VkImageObj image(m_device);
10278 image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
10279 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
10280
sfricke-samsung1c61f192021-12-31 01:53:03 -060010281 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010282 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
10283 color_attachment.imageView = imageView;
10284
10285 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
10286
sfricke-samsung1c61f192021-12-31 01:53:03 -060010287 VkCommandBufferInheritanceRenderingInfoKHR inheritance_rendering_info =
10288 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010289 inheritance_rendering_info.colorAttachmentCount = 1;
10290 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
10291 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_2_BIT;
10292
sfricke-samsung1c61f192021-12-31 01:53:03 -060010293 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010294 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
10295 begin_rendering_info.colorAttachmentCount = 1;
10296 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010297 begin_rendering_info.layerCount = 1;
stusmithcba0c502021-12-21 17:16:28 +000010298
10299 // A pool we can reset in.
10300 VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
10301 VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
10302
10303 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
10304 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
10305 &inheritance_rendering_info, // pNext
10306 VK_NULL_HANDLE,
10307 0, // subpass
10308 VK_NULL_HANDLE,
10309 };
10310
10311 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
10312 nullptr, // pNext
10313 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
10314 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10315 secondary.begin(&cmdbuff__bi);
10316 secondary.end();
10317
10318 m_commandBuffer->begin();
10319
10320 // color samples mismatch
10321 m_commandBuffer->BeginRendering(begin_rendering_info);
10322 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06035");
10323 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10324 m_errorMonitor->VerifyFound();
10325 m_commandBuffer->EndRendering();
10326
10327 VkImageObj depthStencilImage(m_device);
10328 auto depth_stencil_format = FindSupportedDepthStencilFormat(gpu());
10329 if (!depth_stencil_format) {
10330 printf("%s Couldn't depth stencil image format.\n", kSkipPrefix);
10331 return;
10332 }
10333 depthStencilImage.Init(32, 32, 1, depth_stencil_format, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL,
10334 0);
10335 VkImageView depthStencilImageView =
10336 depthStencilImage.targetView(depth_stencil_format, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
10337
sfricke-samsung1c61f192021-12-31 01:53:03 -060010338 VkRenderingAttachmentInfoKHR depth_stencil_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010339 depth_stencil_attachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
10340 depth_stencil_attachment.imageView = depthStencilImageView;
10341
10342 begin_rendering_info.colorAttachmentCount = 0;
10343 begin_rendering_info.pDepthAttachment = &depth_stencil_attachment;
10344 inheritance_rendering_info.colorAttachmentCount = 0;
10345 inheritance_rendering_info.depthAttachmentFormat = depth_stencil_format;
10346
10347 secondary.begin(&cmdbuff__bi);
10348 secondary.end();
10349
10350 // depth samples mismatch
10351 m_commandBuffer->BeginRendering(begin_rendering_info);
10352 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06036");
10353 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10354 m_errorMonitor->VerifyFound();
10355 m_commandBuffer->EndRendering();
10356
10357 begin_rendering_info.pDepthAttachment = nullptr;
10358 begin_rendering_info.pStencilAttachment = &depth_stencil_attachment;
10359 inheritance_rendering_info.depthAttachmentFormat = VK_FORMAT_UNDEFINED;
10360 inheritance_rendering_info.stencilAttachmentFormat = depth_stencil_format;
10361
10362 secondary.begin(&cmdbuff__bi);
10363 secondary.end();
10364
10365 // stencil samples mismatch
10366 m_commandBuffer->BeginRendering(begin_rendering_info);
10367 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06037");
10368 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10369 m_errorMonitor->VerifyFound();
10370 m_commandBuffer->EndRendering();
10371
10372 m_commandBuffer->end();
10373}
10374
10375TEST_F(VkLayerTest, DynamicRenderingAndExecuteCommandsWithMismatchingImageViewAttachmentSamples) {
10376 TEST_DESCRIPTION(
10377 "Test CmdExecuteCommands inside a render pass begun with CmdBeginRendering that has mismatching that has mismatching "
10378 "attachment samples");
10379
10380 SetTargetApiVersion(VK_API_VERSION_1_1);
10381
10382 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
10383
10384 ASSERT_NO_FATAL_FAILURE(InitFramework());
10385
sjfricked700bc02022-05-30 16:35:06 +090010386 if (!AreRequiredExtensionsEnabled()) {
10387 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
stusmithcba0c502021-12-21 17:16:28 +000010388 }
10389
10390 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010391 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
stusmithcba0c502021-12-21 17:16:28 +000010392 }
10393
10394 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
10395 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
10396 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
10397 if (!dynamic_rendering_features.dynamicRendering) {
10398 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
10399 return;
10400 }
10401
10402 bool amd_samples = false;
10403 if (DeviceExtensionSupported(gpu(), nullptr, VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME)) {
10404 m_device_extension_names.push_back(VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME);
10405 amd_samples = true;
10406 }
10407
10408 bool nv_samples = false;
10409 if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME)) {
10410 m_device_extension_names.push_back(VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME);
10411 nv_samples = true;
10412 }
10413
10414 if (!amd_samples && !nv_samples) {
10415 printf("%s Test requires either VK_AMD_mixed_attachment_samples or VK_NV_framebuffer_mixed_samples, skipping\n",
10416 kSkipPrefix);
10417 return;
10418 }
10419
10420 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
10421
10422 VkImageObj image(m_device);
10423 image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
10424 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
10425
sfricke-samsung1c61f192021-12-31 01:53:03 -060010426 VkRenderingAttachmentInfoKHR color_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010427 color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
10428 color_attachment.imageView = imageView;
10429
10430 VkFormat color_formats = {VK_FORMAT_R8G8B8A8_UNORM};
10431
10432 VkSampleCountFlagBits counts = {VK_SAMPLE_COUNT_2_BIT};
10433 auto samples_info = LvlInitStruct<VkAttachmentSampleCountInfoAMD>();
10434 samples_info.colorAttachmentCount = 1;
10435 samples_info.pColorAttachmentSamples = &counts;
10436
10437 auto inheritance_rendering_info = LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>(&samples_info);
stusmithcba0c502021-12-21 17:16:28 +000010438 inheritance_rendering_info.colorAttachmentCount = 1;
10439 inheritance_rendering_info.pColorAttachmentFormats = &color_formats;
10440 inheritance_rendering_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
10441
sfricke-samsung1c61f192021-12-31 01:53:03 -060010442 VkRenderingInfoKHR begin_rendering_info = LvlInitStruct<VkRenderingInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010443 begin_rendering_info.flags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR;
10444 begin_rendering_info.colorAttachmentCount = 1;
10445 begin_rendering_info.pColorAttachments = &color_attachment;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010446 begin_rendering_info.layerCount = 1;
stusmithcba0c502021-12-21 17:16:28 +000010447
10448 // A pool we can reset in.
10449 VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
10450 VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
10451
10452 const VkCommandBufferInheritanceInfo cmdbuff_ii = {
10453 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
10454 &inheritance_rendering_info, // pNext
10455 VK_NULL_HANDLE,
10456 0, // subpass
10457 VK_NULL_HANDLE,
10458 };
10459
10460 VkCommandBufferBeginInfo cmdbuff__bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
10461 nullptr, // pNext
10462 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
10463 cmdbuff__bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
10464 secondary.begin(&cmdbuff__bi);
10465 secondary.end();
10466
10467 m_commandBuffer->begin();
10468
10469 // color samples mismatch
10470 m_commandBuffer->BeginRendering(begin_rendering_info);
10471 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06032");
10472 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10473 m_errorMonitor->VerifyFound();
10474 m_commandBuffer->EndRendering();
10475
10476 VkImageObj depthStencilImage(m_device);
10477 auto depth_stencil_format = FindSupportedDepthStencilFormat(gpu());
10478 if (!depth_stencil_format) {
10479 printf("%s Couldn't depth stencil image format.\n", kSkipPrefix);
10480 return;
10481 }
10482 depthStencilImage.Init(32, 32, 1, depth_stencil_format, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL,
10483 0);
10484 VkImageView depthStencilImageView =
10485 depthStencilImage.targetView(depth_stencil_format, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
10486
sfricke-samsung1c61f192021-12-31 01:53:03 -060010487 VkRenderingAttachmentInfoKHR depth_stencil_attachment = LvlInitStruct<VkRenderingAttachmentInfoKHR>();
stusmithcba0c502021-12-21 17:16:28 +000010488 depth_stencil_attachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
10489 depth_stencil_attachment.imageView = depthStencilImageView;
10490
10491 samples_info.colorAttachmentCount = 0;
10492 samples_info.pColorAttachmentSamples = nullptr;
10493 begin_rendering_info.colorAttachmentCount = 0;
10494 begin_rendering_info.pDepthAttachment = &depth_stencil_attachment;
10495 inheritance_rendering_info.colorAttachmentCount = 0;
10496 inheritance_rendering_info.depthAttachmentFormat = depth_stencil_format;
10497 samples_info.depthStencilAttachmentSamples = VK_SAMPLE_COUNT_2_BIT;
10498
10499 secondary.begin(&cmdbuff__bi);
10500 secondary.end();
10501
10502 // depth samples mismatch
10503 m_commandBuffer->BeginRendering(begin_rendering_info);
10504 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06033");
10505 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10506 m_errorMonitor->VerifyFound();
10507 m_commandBuffer->EndRendering();
10508
10509 begin_rendering_info.pDepthAttachment = nullptr;
10510 begin_rendering_info.pStencilAttachment = &depth_stencil_attachment;
10511 inheritance_rendering_info.depthAttachmentFormat = VK_FORMAT_UNDEFINED;
10512 inheritance_rendering_info.stencilAttachmentFormat = depth_stencil_format;
10513
10514 secondary.begin(&cmdbuff__bi);
10515 secondary.end();
10516
10517 // stencil samples mismatch
10518 m_commandBuffer->BeginRendering(begin_rendering_info);
10519 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pNext-06034");
10520 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
10521 m_errorMonitor->VerifyFound();
10522 m_commandBuffer->EndRendering();
10523
10524 m_commandBuffer->end();
10525}
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010526
10527TEST_F(VkLayerTest, CopyCommands2V13) {
10528 TEST_DESCRIPTION("Ensure copy_commands2 promotions are validated");
10529
10530 SetTargetApiVersion(VK_API_VERSION_1_3);
10531 ASSERT_NO_FATAL_FAILURE(Init());
10532 if (DeviceValidationVersion() < VK_API_VERSION_1_3) {
sjfrickebdd58dd2022-05-20 14:22:50 +090010533 GTEST_SKIP() << "At least Vulkan version 1.3 is required";
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010534 }
10535 VkImageObj image(m_device);
10536 image.Init(128, 128, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
ziga-lunarg0ce51882022-05-18 14:36:48 +020010537 VkImageObj image2(m_device);
10538 image2.Init(128, 128, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
10539 VK_IMAGE_TILING_OPTIMAL, 0);
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010540 ASSERT_TRUE(image.initialized());
10541 VkBufferObj dst_buffer;
10542 VkMemoryPropertyFlags reqs = 0;
10543 dst_buffer.init_as_dst(*m_device, 128 * 128, reqs);
10544 VkBufferObj src_buffer;
10545 src_buffer.init_as_src(*m_device, 128 * 128, reqs);
10546 auto copy_region = LvlInitStruct<VkImageCopy2>();
10547 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10548 copy_region.srcSubresource.layerCount = 1;
10549 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10550 copy_region.dstSubresource.layerCount = 1;
10551 copy_region.dstOffset = {4, 4, 0};
10552 copy_region.extent.width = 1;
10553 copy_region.extent.height = 1;
10554 copy_region.extent.depth = 1;
10555 auto copy_image_info = LvlInitStruct<VkCopyImageInfo2>();
10556 copy_image_info.srcImage = image.handle();
10557 copy_image_info.srcImageLayout = VK_IMAGE_LAYOUT_GENERAL;
10558 copy_image_info.dstImage = image.handle();
10559 copy_image_info.dstImageLayout = VK_IMAGE_LAYOUT_GENERAL;
10560 copy_image_info.regionCount = 1;
10561 copy_image_info.pRegions = &copy_region;
10562 m_commandBuffer->begin();
10563 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstImage-00131");
10564 vk::CmdCopyImage2(m_commandBuffer->handle(), &copy_image_info);
10565 m_errorMonitor->VerifyFound();
10566 auto copy_buffer = LvlInitStruct<VkBufferCopy2>();
ziga-lunarg852187f2022-03-16 21:21:33 +010010567 copy_buffer.dstOffset = 4;
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010568 copy_buffer.size = 4;
10569 auto copy_buffer_info = LvlInitStruct<VkCopyBufferInfo2>();
10570 copy_buffer_info.srcBuffer = dst_buffer.handle();
10571 copy_buffer_info.dstBuffer = dst_buffer.handle();
10572 copy_buffer_info.regionCount = 1;
10573 copy_buffer_info.pRegions = &copy_buffer;
10574 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyBufferInfo2-srcBuffer-00118");
10575 vk::CmdCopyBuffer2(m_commandBuffer->handle(), &copy_buffer_info);
10576 m_errorMonitor->VerifyFound();
10577 auto bic_region = LvlInitStruct<VkBufferImageCopy2>();
10578 bic_region.bufferRowLength = 128;
10579 bic_region.bufferImageHeight = 128;
10580 bic_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10581 bic_region.imageSubresource.layerCount = 1;
10582 bic_region.imageExtent.height = 4;
10583 bic_region.imageExtent.width = 4;
10584 bic_region.imageExtent.depth = 1;
10585 VkCopyBufferToImageInfo2KHR buffer_image_info = LvlInitStruct<VkCopyBufferToImageInfo2>();
10586 buffer_image_info.srcBuffer = src_buffer.handle();
10587 buffer_image_info.dstImage = image.handle();
10588 buffer_image_info.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
10589 buffer_image_info.regionCount = 1;
10590 buffer_image_info.pRegions = &bic_region;
10591 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyBufferToImageInfo2-dstImage-00177");
10592 vk::CmdCopyBufferToImage2(m_commandBuffer->handle(), &buffer_image_info);
10593 m_errorMonitor->VerifyFound();
10594 auto image_buffer_info = LvlInitStruct<VkCopyImageToBufferInfo2>();
10595 image_buffer_info.dstBuffer = src_buffer.handle();
10596 image_buffer_info.srcImage = image.handle();
10597 image_buffer_info.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
10598 image_buffer_info.regionCount = 1;
10599 image_buffer_info.pRegions = &bic_region;
10600 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageToBufferInfo2-dstBuffer-00191");
10601 vk::CmdCopyImageToBuffer2(m_commandBuffer->handle(), &image_buffer_info);
10602 m_errorMonitor->VerifyFound();
10603 auto blit_region = LvlInitStruct<VkImageBlit2>();
10604 blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10605 blit_region.srcSubresource.baseArrayLayer = 0;
10606 blit_region.srcSubresource.layerCount = 1;
10607 blit_region.srcSubresource.mipLevel = 0;
10608 blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10609 blit_region.dstSubresource.baseArrayLayer = 0;
10610 blit_region.dstSubresource.layerCount = 1;
10611 blit_region.dstSubresource.mipLevel = 0;
10612 blit_region.srcOffsets[0] = {0, 0, 0};
aitor-lunarg3ad811f2022-03-31 22:00:39 +020010613 blit_region.srcOffsets[1] = {31, 31, 1};
10614 blit_region.dstOffsets[0] = {32, 32, 0};
10615 blit_region.dstOffsets[1] = {64, 64, 1};
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010616 auto blit_image_info = LvlInitStruct<VkBlitImageInfo2>();
10617 blit_image_info.srcImage = image.handle();
10618 blit_image_info.srcImageLayout = VK_IMAGE_LAYOUT_GENERAL;
10619 blit_image_info.dstImage = image.handle();
10620 blit_image_info.dstImageLayout = VK_IMAGE_LAYOUT_GENERAL;
10621 blit_image_info.regionCount = 1;
10622 blit_image_info.pRegions = &blit_region;
10623 blit_image_info.filter = VK_FILTER_NEAREST;
10624 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBlitImageInfo2-dstImage-00224");
10625 vk::CmdBlitImage2(m_commandBuffer->handle(), &blit_image_info);
10626 m_errorMonitor->VerifyFound();
10627 auto resolve_region = LvlInitStruct<VkImageResolve2>();
10628 resolve_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10629 resolve_region.srcSubresource.mipLevel = 0;
10630 resolve_region.srcSubresource.baseArrayLayer = 0;
10631 resolve_region.srcSubresource.layerCount = 1;
10632 resolve_region.srcOffset.x = 0;
10633 resolve_region.srcOffset.y = 0;
10634 resolve_region.srcOffset.z = 0;
10635 resolve_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
10636 resolve_region.dstSubresource.mipLevel = 0;
10637 resolve_region.dstSubresource.baseArrayLayer = 0;
10638 resolve_region.dstSubresource.layerCount = 1;
10639 resolve_region.dstOffset.x = 0;
10640 resolve_region.dstOffset.y = 0;
10641 resolve_region.dstOffset.z = 0;
10642 resolve_region.extent.width = 1;
10643 resolve_region.extent.height = 1;
10644 resolve_region.extent.depth = 1;
10645 auto resolve_image_info = LvlInitStruct<VkResolveImageInfo2>();
10646 resolve_image_info.srcImage = image.handle();
10647 resolve_image_info.srcImageLayout = VK_IMAGE_LAYOUT_GENERAL;
ziga-lunarg0ce51882022-05-18 14:36:48 +020010648 resolve_image_info.dstImage = image2.handle();
Tony-LunarG7d584ce2022-01-17 13:52:40 -070010649 resolve_image_info.dstImageLayout = VK_IMAGE_LAYOUT_GENERAL;
10650 resolve_image_info.regionCount = 1;
10651 resolve_image_info.pRegions = &resolve_region;
10652 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkResolveImageInfo2-srcImage-00257");
10653 vk::CmdResolveImage2(m_commandBuffer->handle(), &resolve_image_info);
10654 m_errorMonitor->VerifyFound();
10655}
aitor-lunarga131fca2022-02-17 22:55:55 +010010656
10657TEST_F(VkLayerTest, ValidateMultiviewUnboundResourcesAfterBeginRenderPassAndNextSubpass) {
10658 TEST_DESCRIPTION(
10659 "Validate all required resources are bound if multiview is enabled after vkCmdBeginRenderPass and vkCmdNextSubpass");
10660
Aitor Camacho768bbc92022-06-10 16:57:44 +020010661 constexpr unsigned multiview_count = 2u;
10662 constexpr unsigned extra_subpass_count = multiview_count - 1u;
10663
sjfricked700bc02022-05-30 16:35:06 +090010664 AddRequiredExtensions(VK_KHR_MULTIVIEW_EXTENSION_NAME);
aitor-lunarga131fca2022-02-17 22:55:55 +010010665 ASSERT_NO_FATAL_FAILURE(InitFramework());
sjfricked700bc02022-05-30 16:35:06 +090010666 if (!AreRequiredExtensionsEnabled()) {
10667 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
aitor-lunarga131fca2022-02-17 22:55:55 +010010668 }
10669
10670 auto multiview_features = LvlInitStruct<VkPhysicalDeviceMultiviewFeatures>();
Aitor Camacho768bbc92022-06-10 16:57:44 +020010671 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2KHR>(&multiview_features);
10672 auto vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(
10673 vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"));
10674 vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
10675 if (multiview_features.multiview == VK_FALSE) {
10676 GTEST_SKIP() << "Device does not support multiview.";
10677 }
aitor-lunarga131fca2022-02-17 22:55:55 +010010678
Aitor Camacho768bbc92022-06-10 16:57:44 +020010679 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
aitor-lunarga131fca2022-02-17 22:55:55 +010010680
10681 VkAttachmentDescription attachmentDescription = {};
10682 attachmentDescription.format = VK_FORMAT_R8G8B8A8_UNORM;
10683 attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
Nathaniel Cesario0d50bcf2022-06-21 10:30:04 -060010684 attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
aitor-lunarga131fca2022-02-17 22:55:55 +010010685 attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
10686
10687 VkAttachmentReference colorAttachmentReference = {};
10688 colorAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
10689 colorAttachmentReference.attachment = 0;
10690
Aitor Camacho768bbc92022-06-10 16:57:44 +020010691 m_renderPass_subpasses.resize(multiview_count);
10692 for (unsigned i = 0; i < multiview_count; ++i) {
10693 m_renderPass_subpasses[i].colorAttachmentCount = 1;
10694 m_renderPass_subpasses[i].pColorAttachments = &colorAttachmentReference;
10695 }
aitor-lunarga131fca2022-02-17 22:55:55 +010010696
Aitor Camacho768bbc92022-06-10 16:57:44 +020010697 uint32_t viewMasks[multiview_count] = {};
10698 for (unsigned i = 0; i < multiview_count; ++i) {
10699 viewMasks[i] = 1u << i;
10700 }
10701 auto renderPassMultiviewCreateInfo = LvlInitStruct<VkRenderPassMultiviewCreateInfo>();
10702 renderPassMultiviewCreateInfo.subpassCount = multiview_count;
aitor-lunarga131fca2022-02-17 22:55:55 +010010703 renderPassMultiviewCreateInfo.pViewMasks = viewMasks;
10704
10705 m_renderPass_info = LvlInitStruct<VkRenderPassCreateInfo>(&renderPassMultiviewCreateInfo);
10706 m_renderPass_info.attachmentCount = 1;
10707 m_renderPass_info.pAttachments = &attachmentDescription;
10708 m_renderPass_info.subpassCount = m_renderPass_subpasses.size();
10709 m_renderPass_info.pSubpasses = m_renderPass_subpasses.data();
10710
Aitor Camacho768bbc92022-06-10 16:57:44 +020010711 m_renderPass_dependencies.resize(extra_subpass_count);
10712 for (unsigned i = 0; i < m_renderPass_dependencies.size(); ++i) {
10713 auto &subpass_dep = m_renderPass_dependencies[i];
10714 subpass_dep.srcSubpass = i;
10715 subpass_dep.dstSubpass = i + 1;
10716
10717 subpass_dep.srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
10718 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
10719 subpass_dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
10720 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
10721
10722 subpass_dep.srcAccessMask = VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
10723 VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
10724 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
10725 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
10726 subpass_dep.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
10727 VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
10728 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
10729 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
10730
10731 subpass_dep.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
10732 }
aitor-lunarga131fca2022-02-17 22:55:55 +010010733
10734 m_renderPass_info.dependencyCount = static_cast<uint32_t>(m_renderPass_dependencies.size());
10735 m_renderPass_info.pDependencies = m_renderPass_dependencies.data();
10736
10737 vk::CreateRenderPass(m_device->handle(), &m_renderPass_info, nullptr, &m_renderPass);
10738
Aitor Camacho768bbc92022-06-10 16:57:44 +020010739 auto image_create_info = LvlInitStruct<VkImageCreateInfo>();
aitor-lunarga131fca2022-02-17 22:55:55 +010010740 image_create_info.imageType = VK_IMAGE_TYPE_2D;
10741 image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
10742 image_create_info.extent.width = static_cast<uint32_t>(m_width);
10743 image_create_info.extent.height = static_cast<uint32_t>(m_height);
10744 image_create_info.extent.depth = 1;
10745 image_create_info.mipLevels = 1;
Aitor Camacho768bbc92022-06-10 16:57:44 +020010746 image_create_info.arrayLayers = multiview_count;
aitor-lunarga131fca2022-02-17 22:55:55 +010010747 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
10748 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
10749 image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
10750 image_create_info.flags = 0;
10751
10752 VkImageObj image(m_device);
10753 image.Init(image_create_info);
Aitor Camacho768bbc92022-06-10 16:57:44 +020010754 image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
aitor-lunarga131fca2022-02-17 22:55:55 +010010755 VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0,
10756 VK_REMAINING_ARRAY_LAYERS, VK_IMAGE_VIEW_TYPE_2D_ARRAY);
10757
Aitor Camacho768bbc92022-06-10 16:57:44 +020010758 auto framebufferCreateInfo = LvlInitStruct<VkFramebufferCreateInfo>();
aitor-lunarga131fca2022-02-17 22:55:55 +010010759 framebufferCreateInfo.width = static_cast<uint32_t>(m_width);
10760 framebufferCreateInfo.height = static_cast<uint32_t>(m_height);
10761 framebufferCreateInfo.layers = 1;
10762 framebufferCreateInfo.renderPass = m_renderPass;
10763 framebufferCreateInfo.attachmentCount = 1;
10764 framebufferCreateInfo.pAttachments = &imageView;
10765
10766 vk::CreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &m_framebuffer);
10767
10768 VkClearValue clear{};
10769 clear.color = m_clear_color;
10770 m_renderPassClearValues.emplace_back(clear);
10771 m_renderPassBeginInfo.renderPass = m_renderPass;
10772 m_renderPassBeginInfo.framebuffer = m_framebuffer;
10773 m_renderPassBeginInfo.renderArea.extent.width = static_cast<uint32_t>(m_width);
10774 m_renderPassBeginInfo.renderArea.extent.height = static_cast<uint32_t>(m_height);
10775 m_renderPassBeginInfo.clearValueCount = m_renderPassClearValues.size();
10776 m_renderPassBeginInfo.pClearValues = m_renderPassClearValues.data();
10777
Aitor Camacho768bbc92022-06-10 16:57:44 +020010778 // Pipeline not bound test
10779 {
10780 // No need to create individual pipelines for each subpass since we are checking no bound pipeline
10781 CreatePipelineHelper pipe(*this);
10782 pipe.InitInfo();
10783 pipe.InitState();
10784 pipe.CreateGraphicsPipeline();
aitor-lunarga131fca2022-02-17 22:55:55 +010010785
Aitor Camacho768bbc92022-06-10 16:57:44 +020010786 m_commandBuffer->begin();
10787 // This bind should not be valid after we begin the renderpass
10788 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
10789 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
aitor-lunarga131fca2022-02-17 22:55:55 +010010790
Aitor Camacho768bbc92022-06-10 16:57:44 +020010791 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02700");
10792 m_commandBuffer->Draw(1, 0, 0, 0);
10793 m_errorMonitor->VerifyFound();
aitor-lunarga131fca2022-02-17 22:55:55 +010010794
Aitor Camacho768bbc92022-06-10 16:57:44 +020010795 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camacho768bbc92022-06-10 16:57:44 +020010796 // This bind should not be valid for next subpass
10797 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
10798 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
aitor-lunarga131fca2022-02-17 22:55:55 +010010799
Aitor Camacho768bbc92022-06-10 16:57:44 +020010800 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02700");
10801 m_commandBuffer->Draw(1, 0, 0, 0);
10802 m_errorMonitor->VerifyFound();
10803 }
10804
Aitor Camacho768bbc92022-06-10 16:57:44 +020010805 m_commandBuffer->EndRenderPass();
10806 m_commandBuffer->end();
10807 }
10808
10809 m_commandBuffer->reset();
10810
Aitor Camacho131d2192022-06-13 19:15:11 +020010811 // Dynamic state (checking with line width)
10812 {
10813 // Pipeline for subpass 0
10814 CreatePipelineHelper pipe(*this);
10815 pipe.InitInfo();
10816
10817 VkDynamicState dyn_states = VK_DYNAMIC_STATE_LINE_WIDTH;
10818 pipe.ia_ci_.topology = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
10819 pipe.dyn_state_ci_ = LvlInitStruct<VkPipelineDynamicStateCreateInfo>();
10820 pipe.dyn_state_ci_.dynamicStateCount = 1;
10821 pipe.dyn_state_ci_.pDynamicStates = &dyn_states;
10822 pipe.InitState();
10823 pipe.CreateGraphicsPipeline();
10824
10825 // Pipelines for all other subpasses
10826 vk_testing::Pipeline pipelines[extra_subpass_count];
10827 for (unsigned i = 0; i < extra_subpass_count; ++i) {
10828 auto pipe_info = pipe.gp_ci_;
10829 pipe_info.subpass = i + 1;
10830 pipelines[i].init(*m_device, pipe_info);
10831 }
10832
10833 m_commandBuffer->begin();
10834 // This line width set should not be valid for next subpass
10835 vk::CmdSetLineWidth(m_commandBuffer->handle(), 1.0f);
10836 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
10837 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
Aitor Camacho131d2192022-06-13 19:15:11 +020010838
10839 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-commandBuffer-02701");
10840 vk::CmdDraw(m_commandBuffer->handle(), 1, 0, 0, 0);
10841 m_errorMonitor->VerifyFound();
10842
10843 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camacho131d2192022-06-13 19:15:11 +020010844 // This line width set should not be valid for next subpass
10845 vk::CmdSetLineWidth(m_commandBuffer->handle(), 1.0f);
10846 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
10847 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[i].handle());
Aitor Camacho131d2192022-06-13 19:15:11 +020010848
10849 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-commandBuffer-02701");
10850 m_commandBuffer->Draw(1, 0, 0, 0);
10851 m_errorMonitor->VerifyFound();
10852 }
10853
Aitor Camacho131d2192022-06-13 19:15:11 +020010854 m_commandBuffer->EndRenderPass();
10855 m_commandBuffer->end();
10856 }
10857
10858 m_commandBuffer->reset();
10859
Aitor Camacho1f04dea2022-06-13 20:40:44 +020010860 // Push constants
10861 {
10862 char const *const vsSource = R"glsl(
10863 #version 450
10864 layout(push_constant, std430) uniform foo {
10865 mat3 m;
10866 } constants;
10867 void main(){
10868 vec3 v3 = constants.m[0];
10869 }
10870 )glsl";
10871
10872 VkShaderObj const vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
10873 VkShaderObj const fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
10874
10875 VkPushConstantRange push_constant_range = {VK_SHADER_STAGE_VERTEX_BIT, 0, 16};
10876 auto pipeline_layout_info = LvlInitStruct<VkPipelineLayoutCreateInfo>();
10877 pipeline_layout_info.pushConstantRangeCount = 1;
10878 pipeline_layout_info.pPushConstantRanges = &push_constant_range;
10879
10880 vk_testing::PipelineLayout layout;
10881 layout.init(*m_device, pipeline_layout_info, std::vector<const vk_testing::DescriptorSetLayout *>{});
10882
10883 CreatePipelineHelper pipe(*this);
10884 pipe.InitInfo();
10885 pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
10886 pipe.pipeline_layout_ci_ = pipeline_layout_info;
10887 pipe.InitState();
10888 pipe.CreateGraphicsPipeline();
10889
10890 // Pipelines for all other subpasses
10891 vk_testing::Pipeline pipelines[extra_subpass_count];
10892 for (unsigned i = 0; i < extra_subpass_count; ++i) {
10893 auto pipe_info = pipe.gp_ci_;
10894 pipe_info.subpass = i + 1;
10895 pipelines[i].init(*m_device, pipe_info);
10896 }
10897 // Set up complete
10898
10899 const float dummy_values[16] = {};
10900 m_commandBuffer->begin();
10901 // This push constants should not be counted when render pass begins
10902 vk::CmdPushConstants(m_commandBuffer->handle(), layout.handle(), VK_SHADER_STAGE_VERTEX_BIT, push_constant_range.offset,
10903 push_constant_range.size, dummy_values);
10904 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
10905 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
Aitor Camacho1f04dea2022-06-13 20:40:44 +020010906
10907 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-maintenance4-06425");
10908 m_commandBuffer->Draw(1, 0, 0, 0);
10909 m_errorMonitor->VerifyFound();
10910
10911 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camacho1f04dea2022-06-13 20:40:44 +020010912 // This push constants should not be counted when we change subpass
10913 vk::CmdPushConstants(m_commandBuffer->handle(), layout.handle(), VK_SHADER_STAGE_VERTEX_BIT, push_constant_range.offset,
10914 push_constant_range.size, dummy_values);
10915 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
10916 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[i].handle());
Aitor Camacho1f04dea2022-06-13 20:40:44 +020010917
10918 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-maintenance4-06425");
10919 m_commandBuffer->Draw(1, 0, 0, 0);
10920 m_errorMonitor->VerifyFound();
10921 }
10922
Aitor Camacho1f04dea2022-06-13 20:40:44 +020010923 m_commandBuffer->EndRenderPass();
10924 m_commandBuffer->end();
10925 }
10926
10927 m_commandBuffer->reset();
10928
Aitor Camacho097a2322022-06-14 14:08:23 +020010929 // Descriptor sets
10930 {
10931 OneOffDescriptorSet descriptor_set{m_device, {{0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_ALL, nullptr}}};
10932
10933 auto bci = LvlInitStruct<VkBufferCreateInfo>();
10934 bci.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
10935 bci.size = 8;
10936 VkBufferObj buffer;
10937 buffer.init(*m_device, bci);
10938 VkDescriptorBufferInfo buffer_info;
10939 buffer_info.buffer = buffer.handle();
10940 buffer_info.offset = 0;
10941 buffer_info.range = VK_WHOLE_SIZE;
10942 auto descriptor_write = LvlInitStruct<VkWriteDescriptorSet>();
10943 descriptor_write.dstSet = descriptor_set.set_;
10944 descriptor_write.dstBinding = 0;
10945 descriptor_write.descriptorCount = 1;
10946 descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
10947 descriptor_write.pBufferInfo = &buffer_info;
10948 vk::UpdateDescriptorSets(m_device->device(), 1, &descriptor_write, 0, NULL);
10949
10950 auto pipeline_layout_info = LvlInitStruct<VkPipelineLayoutCreateInfo>();
10951 pipeline_layout_info.setLayoutCount = 1;
10952 pipeline_layout_info.pSetLayouts = &descriptor_set.layout_.handle();
10953
10954 vk_testing::PipelineLayout layout;
10955 layout.init(*m_device, pipeline_layout_info, std::vector<vk_testing::DescriptorSetLayout const *>{});
10956
10957 VkShaderObj const vs(this, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT);
10958 VkShaderObj const fs(this, bindStateFragUniformShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
10959
10960 CreatePipelineHelper pipe(*this);
10961 pipe.InitInfo();
10962 pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
10963 pipe.pipeline_layout_ci_ = pipeline_layout_info;
10964 pipe.InitState();
10965 pipe.CreateGraphicsPipeline();
10966
10967 // Pipelines for all other subpasses
10968 vk_testing::Pipeline pipelines[extra_subpass_count];
10969 for (unsigned i = 0; i < extra_subpass_count; ++i) {
10970 auto pipe_info = pipe.gp_ci_;
10971 pipe_info.subpass = i + 1;
10972 pipelines[i].init(*m_device, pipe_info);
10973 }
10974 // Set up complete
10975
10976 m_commandBuffer->begin();
10977 // This descriptor bind should not be counted when render pass begins
10978 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
10979 &descriptor_set.set_, 0, nullptr);
10980 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
10981 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
Aitor Camacho097a2322022-06-14 14:08:23 +020010982
10983 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02697");
10984 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-DescriptorSetNotBound");
10985 m_commandBuffer->Draw(1, 0, 0, 0);
10986 m_errorMonitor->VerifyFound();
10987
10988 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camacho097a2322022-06-14 14:08:23 +020010989 // This descriptor bind should not be counted when next subpass begins
10990 vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0,
10991 1, &descriptor_set.set_, 0, nullptr);
10992 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
10993 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[i].handle());
Aitor Camacho097a2322022-06-14 14:08:23 +020010994
10995 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02697");
10996 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-DescriptorSetNotBound");
10997 m_commandBuffer->Draw(1, 0, 0, 0);
10998 m_errorMonitor->VerifyFound();
10999 }
11000
Aitor Camacho097a2322022-06-14 14:08:23 +020011001 m_commandBuffer->EndRenderPass();
11002 m_commandBuffer->end();
11003 }
11004
11005 m_commandBuffer->reset();
11006
Aitor Camachob379c4b2022-06-14 14:43:40 +020011007 // Vertex buffer
11008 {
11009 float const vertex_data[] = {1.0f, 0.0f};
11010 VkConstantBufferObj vbo(m_device, static_cast<int>(sizeof(vertex_data)), reinterpret_cast<const void *>(vertex_data),
11011 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
11012
11013 VkVertexInputBindingDescription input_binding{};
11014 input_binding.binding = 0;
11015 input_binding.stride = sizeof(vertex_data);
11016 input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
11017
11018 VkVertexInputAttributeDescription input_attribs{};
11019 input_attribs.binding = 0;
11020 input_attribs.location = 0;
11021 input_attribs.format = VK_FORMAT_R32G32_SFLOAT;
11022 input_attribs.offset = 0;
11023
11024 char const *const vsSource = R"glsl(
11025 #version 450
11026 layout(location = 0) in vec2 input0;
11027 void main(){
11028 gl_Position = vec4(input0.x, input0.y, 0.0f, 1.0f);
11029 }
11030 )glsl";
11031
11032 VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
11033 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
11034
11035 CreatePipelineHelper pipe(*this);
11036 pipe.InitInfo();
11037 pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
11038 pipe.vi_ci_.vertexBindingDescriptionCount = 1;
11039 pipe.vi_ci_.pVertexBindingDescriptions = &input_binding;
11040 pipe.vi_ci_.vertexAttributeDescriptionCount = 1;
11041 pipe.vi_ci_.pVertexAttributeDescriptions = &input_attribs;
11042 pipe.InitState();
11043 pipe.CreateGraphicsPipeline();
11044
11045 // Pipelines for all other subpasses
11046 vk_testing::Pipeline pipelines[extra_subpass_count];
11047 for (unsigned i = 0; i < extra_subpass_count; ++i) {
11048 auto pipe_info = pipe.gp_ci_;
11049 pipe_info.subpass = i + 1;
11050 pipelines[i].init(*m_device, pipe_info);
11051 }
11052 // Set up complete
11053 VkDeviceSize offset = 0;
11054
11055 m_commandBuffer->begin();
11056 // This vertex buffer bind should not be counted when render pass begins
11057 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
11058 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
11059 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
Aitor Camachob379c4b2022-06-14 14:43:40 +020011060
11061 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-04007");
11062 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721");
11063 m_commandBuffer->Draw(1, 0, 0, 0);
11064 m_errorMonitor->VerifyFound();
11065
11066 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camachob379c4b2022-06-14 14:43:40 +020011067 // This vertex buffer bind should not be counted when next subpass begins
11068 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
11069 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
11070 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[i].handle());
Aitor Camachob379c4b2022-06-14 14:43:40 +020011071
11072 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-04007");
11073 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDraw-None-02721");
11074 m_commandBuffer->Draw(1, 0, 0, 0);
11075 m_errorMonitor->VerifyFound();
11076 }
11077
Aitor Camachob379c4b2022-06-14 14:43:40 +020011078 m_commandBuffer->EndRenderPass();
11079 m_commandBuffer->end();
11080 }
11081
11082 m_commandBuffer->reset();
11083
Aitor Camachoea9030a2022-06-14 15:07:25 +020011084 // Index buffer
11085 {
11086 float const vertex_data[] = {1.0f, 0.0f};
11087 VkConstantBufferObj vbo(m_device, static_cast<int>(sizeof(vertex_data)), reinterpret_cast<const void *>(vertex_data),
11088 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
11089
11090 uint32_t const index_data[] = {0};
11091 VkConstantBufferObj ibo(m_device, static_cast<int>(sizeof(index_data)), reinterpret_cast<const void *>(index_data),
11092 VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
11093
11094 VkVertexInputBindingDescription input_binding{};
11095 input_binding.binding = 0;
11096 input_binding.stride = sizeof(vertex_data);
11097 input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
11098
11099 VkVertexInputAttributeDescription input_attribs{};
11100 input_attribs.binding = 0;
11101 input_attribs.location = 0;
11102 input_attribs.format = VK_FORMAT_R32G32_SFLOAT;
11103 input_attribs.offset = 0;
11104
11105 char const *const vsSource = R"glsl(
11106 #version 450
11107 layout(location = 0) in vec2 input0;
11108 void main(){
11109 gl_Position = vec4(input0.x, input0.y, 0.0f, 1.0f);
11110 }
11111 )glsl";
11112
11113 VkShaderObj vs(this, vsSource, VK_SHADER_STAGE_VERTEX_BIT);
11114 VkShaderObj fs(this, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT);
11115
11116 CreatePipelineHelper pipe(*this);
11117 pipe.InitInfo();
11118 pipe.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
11119 pipe.vi_ci_.vertexBindingDescriptionCount = 1;
11120 pipe.vi_ci_.pVertexBindingDescriptions = &input_binding;
11121 pipe.vi_ci_.vertexAttributeDescriptionCount = 1;
11122 pipe.vi_ci_.pVertexAttributeDescriptions = &input_attribs;
11123 pipe.InitState();
11124 pipe.CreateGraphicsPipeline();
11125
11126 // Pipelines for all other subpasses
11127 vk_testing::Pipeline pipelines[extra_subpass_count];
11128 for (unsigned i = 0; i < extra_subpass_count; ++i) {
11129 auto pipe_info = pipe.gp_ci_;
11130 pipe_info.subpass = i + 1;
11131 pipelines[i].init(*m_device, pipe_info);
11132 }
11133 // Set up complete
11134
11135 VkDeviceSize offset = 0;
11136 m_commandBuffer->begin();
11137 // This index buffer bind should not be counted when render pass begins
11138 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), ibo.handle(), 0, VK_INDEX_TYPE_UINT32);
11139 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
11140 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
11141 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
Aitor Camachoea9030a2022-06-14 15:07:25 +020011142
11143 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02701");
11144 m_commandBuffer->DrawIndexed(0, 1, 0, 0, 0);
11145 m_errorMonitor->VerifyFound();
11146
11147 for (unsigned i = 0; i < extra_subpass_count; ++i) {
Aitor Camachoea9030a2022-06-14 15:07:25 +020011148 // This index buffer bind should not be counted when next subpass begins
11149 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), ibo.handle(), 0, VK_INDEX_TYPE_UINT32);
11150 vk::CmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
11151 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[i].handle());
11152 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
Aitor Camachoea9030a2022-06-14 15:07:25 +020011153
11154 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexed-commandBuffer-02701");
11155 m_commandBuffer->DrawIndexed(0, 1, 0, 0, 0);
11156 m_errorMonitor->VerifyFound();
11157 }
11158
Aitor Camachoea9030a2022-06-14 15:07:25 +020011159 m_commandBuffer->EndRenderPass();
11160 m_commandBuffer->end();
11161 }
aitor-lunarga131fca2022-02-17 22:55:55 +010011162}
ziga-lunarg813fa012022-04-09 14:09:57 +020011163
11164TEST_F(VkLayerTest, TestCommandBufferInheritanceWithInvalidDepthFormat) {
11165 TEST_DESCRIPTION(
11166 "Test VkCommandBufferInheritanceRenderingInfoKHR with depthAttachmentFormat that does not include depth aspect");
11167
11168 SetTargetApiVersion(VK_API_VERSION_1_1);
11169
11170 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
11171
11172 ASSERT_NO_FATAL_FAILURE(InitFramework());
11173
sjfricked700bc02022-05-30 16:35:06 +090011174 if (!AreRequiredExtensionsEnabled()) {
11175 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
ziga-lunarg813fa012022-04-09 14:09:57 +020011176 }
11177
11178 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
sjfrickebdd58dd2022-05-20 14:22:50 +090011179 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
ziga-lunarg813fa012022-04-09 14:09:57 +020011180 }
11181
11182 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
11183 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
11184 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
11185 if (!dynamic_rendering_features.dynamicRendering) {
11186 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
11187 return;
11188 }
11189
11190 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
11191
11192 auto stencil_format = FindSupportedStencilOnlyFormat(gpu());
11193 if (!stencil_format) {
11194 printf("%s Couldn't stencil image format.\n", kSkipPrefix);
11195 return;
11196 }
11197
11198 auto inheritance_rendering_info = LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
11199 inheritance_rendering_info.depthAttachmentFormat = stencil_format;
11200
11201 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
11202
11203 auto cmdbuf_ii = LvlInitStruct<VkCommandBufferInheritanceInfo>(&inheritance_rendering_info);
11204 auto cmdbuf_bi = LvlInitStruct<VkCommandBufferBeginInfo>();
11205 cmdbuf_bi.pInheritanceInfo = &cmdbuf_ii;
11206
11207 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCommandBufferInheritanceRenderingInfo-depthAttachmentFormat-06540");
11208
11209 vk::BeginCommandBuffer(secondary.handle(), &cmdbuf_bi);
11210
11211 m_errorMonitor->VerifyFound();
11212}
ziga-lunarg0ce51882022-05-18 14:36:48 +020011213
11214TEST_F(VkLayerTest, ResolveInvalidUsage) {
11215 TEST_DESCRIPTION("Resolve image with missing usage flags.");
11216
sjfricke3a10ae82022-08-02 18:48:57 +090011217 if (!OverrideDevsimForDeviceProfileLayer()) {
11218 GTEST_SKIP() << "Failed to override devsim for device profile layer.";
ziga-lunarg0ce51882022-05-18 14:36:48 +020011219 }
11220
11221 ASSERT_NO_FATAL_FAILURE(Init());
11222
11223 PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr;
11224 PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr;
ziga-lunarg0ce51882022-05-18 14:36:48 +020011225 if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) {
sjfricke3a10ae82022-08-02 18:48:57 +090011226 GTEST_SKIP() << "Failed to load device profile layer.";
ziga-lunarg0ce51882022-05-18 14:36:48 +020011227 }
11228
11229 VkFormat src_format = VK_FORMAT_R8_UNORM;
11230 VkFormat dst_format = VK_FORMAT_R8_SNORM;
11231
11232 VkFormatProperties formatProps;
11233 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), src_format, &formatProps);
11234 formatProps.optimalTilingFeatures &= ~VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
11235 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), src_format, formatProps);
11236 fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), dst_format, &formatProps);
11237 formatProps.optimalTilingFeatures &= ~VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
11238 fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), dst_format, formatProps);
11239
11240 VkImageCreateInfo image_create_info = LvlInitStruct<VkImageCreateInfo>();
11241 image_create_info.imageType = VK_IMAGE_TYPE_2D;
11242 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
11243 image_create_info.extent.width = 32;
11244 image_create_info.extent.height = 1;
11245 image_create_info.extent.depth = 1;
11246 image_create_info.mipLevels = 1;
11247 image_create_info.arrayLayers = 1;
11248 image_create_info.samples = VK_SAMPLE_COUNT_2_BIT;
11249 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
11250 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
11251 image_create_info.flags = 0;
11252
11253 VkImageObj srcImage(m_device);
11254 srcImage.init(&image_create_info);
11255 ASSERT_TRUE(srcImage.initialized());
11256
11257 image_create_info.format = dst_format;
11258 VkImageObj srcImage2(m_device);
11259 srcImage2.init(&image_create_info);
11260 ASSERT_TRUE(srcImage2.initialized());
11261
11262 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
11263 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
11264 VkImageObj invalidSrcImage(m_device);
11265 invalidSrcImage.init(&image_create_info);
11266 ASSERT_TRUE(invalidSrcImage.initialized());
11267
11268 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
11269 image_create_info.format = src_format;
11270 VkImageObj invalidSrcImage2(m_device);
11271 invalidSrcImage2.init(&image_create_info);
11272 ASSERT_TRUE(invalidSrcImage2.initialized());
11273
11274 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
11275 image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
11276 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
11277 image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
11278 VkImageObj dstImage(m_device);
11279 dstImage.init(&image_create_info);
11280 ASSERT_TRUE(dstImage.initialized());
11281
11282 image_create_info.format = src_format;
11283 VkImageObj dstImage2(m_device);
11284 dstImage2.init(&image_create_info);
11285 ASSERT_TRUE(dstImage2.initialized());
11286
11287 image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
11288 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
11289 VkImageObj invalidDstImage(m_device);
11290 invalidDstImage.init(&image_create_info);
11291 ASSERT_TRUE(invalidDstImage.initialized());
11292
11293 image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
11294 image_create_info.format = dst_format;
11295 VkImageObj invalidDstImage2(m_device);
11296 invalidDstImage2.init(&image_create_info);
11297 ASSERT_TRUE(invalidDstImage2.initialized());
11298
11299 m_commandBuffer->begin();
11300 VkImageResolve resolveRegion;
11301 resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
11302 resolveRegion.srcSubresource.mipLevel = 0;
11303 resolveRegion.srcSubresource.baseArrayLayer = 0;
11304 resolveRegion.srcSubresource.layerCount = 1;
11305 resolveRegion.srcOffset.x = 0;
11306 resolveRegion.srcOffset.y = 0;
11307 resolveRegion.srcOffset.z = 0;
11308 resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
11309 resolveRegion.dstSubresource.mipLevel = 0;
11310 resolveRegion.dstSubresource.baseArrayLayer = 0;
11311 resolveRegion.dstSubresource.layerCount = 1;
11312 resolveRegion.dstOffset.x = 0;
11313 resolveRegion.dstOffset.y = 0;
11314 resolveRegion.dstOffset.z = 0;
11315 resolveRegion.extent.width = 1;
11316 resolveRegion.extent.height = 1;
11317 resolveRegion.extent.depth = 1;
11318
11319 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-06762");
11320 m_commandBuffer->ResolveImage(invalidSrcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
11321 &resolveRegion);
11322 m_errorMonitor->VerifyFound();
11323
11324 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-06764");
11325 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, invalidDstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
11326 &resolveRegion);
11327 m_errorMonitor->VerifyFound();
11328
11329 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImage-06763");
11330 m_commandBuffer->ResolveImage(invalidSrcImage2.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage2.handle(), VK_IMAGE_LAYOUT_GENERAL,
11331 1, &resolveRegion);
11332 m_errorMonitor->VerifyFound();
11333
11334 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImage-06765");
11335 m_commandBuffer->ResolveImage(srcImage2.handle(), VK_IMAGE_LAYOUT_GENERAL, invalidDstImage2.handle(), VK_IMAGE_LAYOUT_GENERAL,
11336 1, &resolveRegion);
11337 m_errorMonitor->VerifyFound();
11338
11339 m_commandBuffer->end();
11340}
ziga-lunarg9cd35db2022-08-05 16:46:30 +020011341
11342TEST_F(VkLayerTest, DynamicRenderingInSecondaryCommandBuffers) {
11343 TEST_DESCRIPTION("Test drawing in secondary command buffers with dynamic rendering");
11344
11345 SetTargetApiVersion(VK_API_VERSION_1_1);
11346
11347 AddRequiredExtensions(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
11348
11349 ASSERT_NO_FATAL_FAILURE(InitFramework());
11350
11351 if (!AreRequiredExtensionsEnabled()) {
11352 GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported";
11353 }
11354
11355 if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
11356 GTEST_SKIP() << "At least Vulkan version 1.1 is required";
11357 }
11358
11359 auto dynamic_rendering_features = LvlInitStruct<VkPhysicalDeviceDynamicRenderingFeaturesKHR>();
11360 auto features2 = LvlInitStruct<VkPhysicalDeviceFeatures2>(&dynamic_rendering_features);
11361 vk::GetPhysicalDeviceFeatures2(gpu(), &features2);
11362 if (!dynamic_rendering_features.dynamicRendering) {
11363 printf("%s Test requires (unsupported) dynamicRendering , skipping\n", kSkipPrefix);
11364 return;
11365 }
11366
11367 ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
11368
11369 VkFormat format = VK_FORMAT_R32G32B32A32_UINT;
11370
11371 auto pipeline_rendering_info = LvlInitStruct<VkPipelineRenderingCreateInfoKHR>();
11372 pipeline_rendering_info.colorAttachmentCount = 1;
11373 pipeline_rendering_info.pColorAttachmentFormats = &format;
11374
11375 CreatePipelineHelper pipe(*this);
11376 pipe.InitInfo();
11377 pipe.gp_ci_.pNext = &pipeline_rendering_info;
11378 pipe.InitState();
11379 pipe.CreateGraphicsPipeline();
11380
11381 VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo =
11382 LvlInitStruct<VkCommandBufferInheritanceRenderingInfoKHR>();
11383 inheritanceRenderingInfo.colorAttachmentCount = 1;
11384 inheritanceRenderingInfo.pColorAttachmentFormats = &format;
11385 inheritanceRenderingInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
11386
11387 VkCommandBufferInheritanceInfo cbii = LvlInitStruct<VkCommandBufferInheritanceInfo>(&inheritanceRenderingInfo);
11388 cbii.renderPass = m_renderPass;
11389 cbii.framebuffer = m_framebuffer;
11390
11391 VkCommandBufferBeginInfo cbbi = LvlInitStruct<VkCommandBufferBeginInfo>();
11392 cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
11393 cbbi.pInheritanceInfo = &cbii;
11394
11395 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
11396 secondary.begin(&cbbi);
11397 vk::CmdBindPipeline(secondary.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
11398 secondary.Draw(3, 1, 0, 0);
11399 secondary.end();
11400}