You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5017 lines
244 KiB
5017 lines
244 KiB
/*
|
|
* Copyright (c) 2015-2019 The Khronos Group Inc.
|
|
* Copyright (c) 2015-2019 Valve Corporation
|
|
* Copyright (c) 2015-2019 LunarG, Inc.
|
|
* Copyright (c) 2015-2019 Google, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Author: Chia-I Wu <olvaffe@gmail.com>
|
|
* Author: Chris Forbes <chrisf@ijw.co.nz>
|
|
* Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
|
|
* Author: Mark Lobodzinski <mark@lunarg.com>
|
|
* Author: Mike Stroyan <mike@LunarG.com>
|
|
* Author: Tobin Ehlis <tobine@google.com>
|
|
* Author: Tony Barbour <tony@LunarG.com>
|
|
* Author: Cody Northrop <cnorthrop@google.com>
|
|
* Author: Dave Houlton <daveh@lunarg.com>
|
|
* Author: Jeremy Kniager <jeremyk@lunarg.com>
|
|
* Author: Shannon McPherson <shannon@lunarg.com>
|
|
* Author: John Zulauf <jzulauf@lunarg.com>
|
|
*/
|
|
|
|
#include "cast_utils.h"
|
|
#include "layer_validation_tests.h"
|
|
|
|
TEST_F(VkLayerTest, InvalidCommandPoolConsistency) {
|
|
TEST_DESCRIPTION("Allocate command buffers from one command pool and attempt to delete them from another.");
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkFreeCommandBuffers-pCommandBuffers-parent");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
VkCommandPool command_pool_one;
|
|
VkCommandPool command_pool_two;
|
|
|
|
VkCommandPoolCreateInfo pool_create_info{};
|
|
pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
|
|
pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
|
|
vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_one);
|
|
|
|
vkCreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_two);
|
|
|
|
VkCommandBuffer cb;
|
|
VkCommandBufferAllocateInfo command_buffer_allocate_info{};
|
|
command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
command_buffer_allocate_info.commandPool = command_pool_one;
|
|
command_buffer_allocate_info.commandBufferCount = 1;
|
|
command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &cb);
|
|
|
|
vkFreeCommandBuffers(m_device->device(), command_pool_two, 1, &cb);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkDestroyCommandPool(m_device->device(), command_pool_one, NULL);
|
|
vkDestroyCommandPool(m_device->device(), command_pool_two, NULL);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, InvalidSecondaryCommandBufferBarrier) {
|
|
TEST_DESCRIPTION("Add an invalid image barrier in a secondary command buffer");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// A renderpass with a single subpass that declared a self-dependency
|
|
VkAttachmentDescription attach[] = {
|
|
{0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
|
|
VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL},
|
|
};
|
|
VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
|
|
VkSubpassDescription subpasses[] = {
|
|
{0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr},
|
|
};
|
|
VkSubpassDependency dep = {0,
|
|
0,
|
|
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
|
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
|
VK_ACCESS_SHADER_WRITE_BIT,
|
|
VK_ACCESS_SHADER_WRITE_BIT,
|
|
VK_DEPENDENCY_BY_REGION_BIT};
|
|
VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 1, subpasses, 1, &dep};
|
|
VkRenderPass rp;
|
|
|
|
VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
VkImageObj image(m_device);
|
|
image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
|
|
VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
|
|
// Second image that img_barrier will incorrectly use
|
|
VkImageObj image2(m_device);
|
|
image2.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
|
|
|
|
VkFramebufferCreateInfo fbci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &imageView, 32, 32, 1};
|
|
VkFramebuffer fb;
|
|
err = vkCreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
|
|
nullptr,
|
|
rp,
|
|
fb,
|
|
{{
|
|
0,
|
|
0,
|
|
},
|
|
{32, 32}},
|
|
0,
|
|
nullptr};
|
|
|
|
vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
|
|
|
|
VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
|
|
VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
VkCommandBufferInheritanceInfo cbii = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
|
|
nullptr,
|
|
rp,
|
|
0,
|
|
VK_NULL_HANDLE, // Set to NULL FB handle intentionally to flesh out any errors
|
|
VK_FALSE,
|
|
0,
|
|
0};
|
|
VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr,
|
|
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
|
|
&cbii};
|
|
vkBeginCommandBuffer(secondary.handle(), &cbbi);
|
|
VkImageMemoryBarrier img_barrier = {};
|
|
img_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
img_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
|
|
img_barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
|
|
img_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
img_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
img_barrier.image = image2.handle(); // Image mis-matches with FB image
|
|
img_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
img_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
img_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
img_barrier.subresourceRange.baseArrayLayer = 0;
|
|
img_barrier.subresourceRange.baseMipLevel = 0;
|
|
img_barrier.subresourceRange.layerCount = 1;
|
|
img_barrier.subresourceRange.levelCount = 1;
|
|
vkCmdPipelineBarrier(secondary.handle(), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
|
VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, &img_barrier);
|
|
secondary.end();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPipelineBarrier-image-02635");
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkDestroyFramebuffer(m_device->device(), fb, nullptr);
|
|
vkDestroyRenderPass(m_device->device(), rp, nullptr);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicDepthBiasNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Depth Bias dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic depth bias
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Dynamic depth bias state not set for this command buffer");
|
|
VKTriangleTest(BsoFailDepthBias);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicLineWidthNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Line Width dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic line width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Dynamic line width state not set for this command buffer");
|
|
VKTriangleTest(BsoFailLineWidth);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicLineStippleNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Line Stipple dynamic state is required but not correctly bound.");
|
|
|
|
if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
std::array<const char *, 1> required_device_extensions = {{VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME}};
|
|
for (auto device_extension : required_device_extensions) {
|
|
if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
|
|
m_device_extension_names.push_back(device_extension);
|
|
} else {
|
|
printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
|
|
return;
|
|
}
|
|
}
|
|
|
|
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
|
|
(PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
|
|
ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
|
|
|
|
auto line_rasterization_features = lvl_init_struct<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
|
|
auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&line_rasterization_features);
|
|
vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
|
|
|
|
if (!line_rasterization_features.stippledBresenhamLines || !line_rasterization_features.bresenhamLines) {
|
|
printf("%sStipple Bresenham lines not supported; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic line stipple state not set for this command buffer");
|
|
VKTriangleTest(BsoFailLineStipple);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicViewportNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Viewport dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic viewport state
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic viewport(s) 0 are used by pipeline state object, but were not provided");
|
|
VKTriangleTest(BsoFailViewport);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicScissorNotBound) {
|
|
TEST_DESCRIPTION("Run a simple draw calls to validate failure when Scissor dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic scissor state
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic scissor(s) 0 are used by pipeline state object, but were not provided");
|
|
VKTriangleTest(BsoFailScissor);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicBlendConstantsNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Blend Constants dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic blend constant state
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic blend constants state not set for this command buffer");
|
|
VKTriangleTest(BsoFailBlend);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicDepthBoundsNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Depth Bounds dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
if (!m_device->phy().features().depthBounds) {
|
|
printf("%s Device does not support depthBounds test; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
// Dynamic depth bounds
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic depth bounds state not set for this command buffer");
|
|
VKTriangleTest(BsoFailDepthBounds);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicStencilReadNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Stencil Read dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic stencil read mask
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic stencil read mask state not set for this command buffer");
|
|
VKTriangleTest(BsoFailStencilReadMask);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicStencilWriteNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Stencil Write dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic stencil write mask
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic stencil write mask state not set for this command buffer");
|
|
VKTriangleTest(BsoFailStencilWriteMask);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DynamicStencilRefNotBound) {
|
|
TEST_DESCRIPTION(
|
|
"Run a simple draw calls to validate failure when Stencil Ref dynamic state is required but not correctly bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
// Dynamic stencil reference
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Dynamic stencil reference state not set for this command buffer");
|
|
VKTriangleTest(BsoFailStencilReference);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, IndexBufferNotBound) {
|
|
TEST_DESCRIPTION("Run an indexed draw call without an index buffer bound.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"Index buffer object not bound to this command buffer when Indexed ");
|
|
VKTriangleTest(BsoFailIndexBuffer);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, IndexBufferBadSize) {
|
|
TEST_DESCRIPTION("Run indexed draw call with bad index buffer size.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdDrawIndexed() index size ");
|
|
VKTriangleTest(BsoFailIndexBufferBadSize);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, IndexBufferBadOffset) {
|
|
TEST_DESCRIPTION("Run indexed draw call with bad index buffer offset.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdDrawIndexed() index size ");
|
|
VKTriangleTest(BsoFailIndexBufferBadOffset);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, IndexBufferBadBindSize) {
|
|
TEST_DESCRIPTION("Run bind index buffer with a size greater than the index buffer.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdDrawIndexed() index size ");
|
|
VKTriangleTest(BsoFailIndexBufferBadMapSize);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, IndexBufferBadBindOffset) {
|
|
TEST_DESCRIPTION("Run bind index buffer with an offset greater than the size of the index buffer.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdDrawIndexed() index size ");
|
|
VKTriangleTest(BsoFailIndexBufferBadMapOffset);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, MissingClearAttachment) {
|
|
TEST_DESCRIPTION("Points to a wrong colorAttachment index in a VkClearAttachment structure passed to vkCmdClearAttachments");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdClearAttachments-aspectMask-02501");
|
|
|
|
VKTriangleTest(BsoFailCmdClearAttachments);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CommandBufferTwoSubmits) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitViewport());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
// We luck out b/c by default the framework creates CB w/ the
|
|
// VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color);
|
|
m_commandBuffer->end();
|
|
|
|
// Bypass framework since it does the waits automatically
|
|
VkResult err = VK_SUCCESS;
|
|
VkSubmitInfo submit_info;
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.pNext = NULL;
|
|
submit_info.waitSemaphoreCount = 0;
|
|
submit_info.pWaitSemaphores = NULL;
|
|
submit_info.pWaitDstStageMask = NULL;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &m_commandBuffer->handle();
|
|
submit_info.signalSemaphoreCount = 0;
|
|
submit_info.pSignalSemaphores = NULL;
|
|
|
|
err = vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
ASSERT_VK_SUCCESS(err);
|
|
vkQueueWaitIdle(m_device->m_queue);
|
|
|
|
// Cause validation error by re-submitting cmd buffer that should only be
|
|
// submitted once
|
|
err = vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
vkQueueWaitIdle(m_device->m_queue);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, InvalidPushConstants) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitViewport());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
VkPipelineLayout pipeline_layout;
|
|
VkPushConstantRange pc_range = {};
|
|
VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
|
|
pipeline_layout_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipeline_layout_ci.pushConstantRangeCount = 1;
|
|
pipeline_layout_ci.pPushConstantRanges = &pc_range;
|
|
|
|
//
|
|
// Check for invalid push constant ranges in pipeline layouts.
|
|
//
|
|
struct PipelineLayoutTestCase {
|
|
VkPushConstantRange const range;
|
|
char const *msg;
|
|
};
|
|
|
|
const uint32_t too_big = m_device->props.limits.maxPushConstantsSize + 0x4;
|
|
const std::array<PipelineLayoutTestCase, 10> range_tests = {{
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 0, 0}, "vkCreatePipelineLayout() call has push constants index 0 with size 0."},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 0, 1}, "vkCreatePipelineLayout() call has push constants index 0 with size 1."},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 4, 1}, "vkCreatePipelineLayout() call has push constants index 0 with size 1."},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 4, 0}, "vkCreatePipelineLayout() call has push constants index 0 with size 0."},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 1, 4}, "vkCreatePipelineLayout() call has push constants index 0 with offset 1. Offset must"},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 0, too_big}, "vkCreatePipelineLayout() call has push constants index 0 with offset "},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, too_big, too_big}, "vkCreatePipelineLayout() call has push constants index 0 with offset "},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, too_big, 4}, "vkCreatePipelineLayout() call has push constants index 0 with offset "},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 0xFFFFFFF0, 0x00000020},
|
|
"vkCreatePipelineLayout() call has push constants index 0 with offset "},
|
|
{{VK_SHADER_STAGE_VERTEX_BIT, 0x00000020, 0xFFFFFFF0},
|
|
"vkCreatePipelineLayout() call has push constants index 0 with offset "},
|
|
}};
|
|
|
|
// Check for invalid offset and size
|
|
for (const auto &iter : range_tests) {
|
|
pc_range = iter.range;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, iter.msg);
|
|
vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
// Check for invalid stage flag
|
|
pc_range.offset = 0;
|
|
pc_range.size = 16;
|
|
pc_range.stageFlags = 0;
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCreatePipelineLayout: value of pCreateInfo->pPushConstantRanges[0].stageFlags must not be 0");
|
|
vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Check for duplicate stage flags in a list of push constant ranges.
|
|
// A shader can only have one push constant block and that block is mapped
|
|
// to the push constant range that has that shader's stage flag set.
|
|
// The shader's stage flag can only appear once in all the ranges, so the
|
|
// implementation can find the one and only range to map it to.
|
|
const uint32_t ranges_per_test = 5;
|
|
struct DuplicateStageFlagsTestCase {
|
|
VkPushConstantRange const ranges[ranges_per_test];
|
|
std::vector<char const *> const msg;
|
|
};
|
|
// Overlapping ranges are OK, but a stage flag can appear only once.
|
|
const std::array<DuplicateStageFlagsTestCase, 3> duplicate_stageFlags_tests = {
|
|
{
|
|
{{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4}},
|
|
{
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 1.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 2.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 4.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 2.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 3.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 4.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 3 and 4.",
|
|
}},
|
|
{{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}},
|
|
{
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.",
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.",
|
|
}},
|
|
{{{VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_VERTEX_BIT, 0, 4},
|
|
{VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}},
|
|
{
|
|
"vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.",
|
|
}},
|
|
},
|
|
};
|
|
|
|
for (const auto &iter : duplicate_stageFlags_tests) {
|
|
pipeline_layout_ci.pPushConstantRanges = iter.ranges;
|
|
pipeline_layout_ci.pushConstantRangeCount = ranges_per_test;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, iter.msg.begin(), iter.msg.end());
|
|
vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
//
|
|
// CmdPushConstants tests
|
|
//
|
|
|
|
// Setup a pipeline layout with ranges: [0,32) [16,80)
|
|
const std::vector<VkPushConstantRange> pc_range2 = {{VK_SHADER_STAGE_VERTEX_BIT, 16, 64},
|
|
{VK_SHADER_STAGE_FRAGMENT_BIT, 0, 32}};
|
|
const VkPipelineLayoutObj pipeline_layout_obj(m_device, {}, pc_range2);
|
|
|
|
const uint8_t dummy_values[100] = {};
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
// Check for invalid stage flag
|
|
// Note that VU 00996 isn't reached due to parameter validation
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdPushConstants: value of stageFlags must not be 0");
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), 0, 0, 16, dummy_values);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Positive tests for the overlapping ranges
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, dummy_values);
|
|
m_errorMonitor->VerifyNotFound();
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 32, 48, dummy_values);
|
|
m_errorMonitor->VerifyNotFound();
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
|
|
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 16, 16, dummy_values);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Wrong cmd stages for extant range
|
|
// No range for all cmd stages -- "VUID-vkCmdPushConstants-offset-01795" VUID-vkCmdPushConstants-offset-01795
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushConstants-offset-01795");
|
|
// Missing cmd stages for found overlapping range -- "VUID-vkCmdPushConstants-offset-01796" VUID-vkCmdPushConstants-offset-01796
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushConstants-offset-01796");
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_GEOMETRY_BIT, 0, 16, dummy_values);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Wrong no extant range
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushConstants-offset-01795");
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 80, 4, dummy_values);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Wrong overlapping extent
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushConstants-offset-01795");
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
|
|
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 20, dummy_values);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Wrong stage flags for valid overlapping range
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushConstants-offset-01796");
|
|
vkCmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 16, 16, dummy_values);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, NoBeginCommandBuffer) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"You must call vkBeginCommandBuffer() before this call to ");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
VkCommandBufferObj commandBuffer(m_device, m_commandPool);
|
|
// Call EndCommandBuffer() w/o calling BeginCommandBuffer()
|
|
vkEndCommandBuffer(commandBuffer.handle());
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SecondaryCommandBufferNullRenderpass) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkCommandBufferObj cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
// Force the failure by not setting the Renderpass and Framebuffer fields
|
|
VkCommandBufferInheritanceInfo cmd_buf_hinfo = {};
|
|
cmd_buf_hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
|
|
|
|
VkCommandBufferBeginInfo cmd_buf_info = {};
|
|
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
cmd_buf_info.pNext = NULL;
|
|
cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
|
|
cmd_buf_info.pInheritanceInfo = &cmd_buf_hinfo;
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkCommandBufferBeginInfo-flags-00053");
|
|
vkBeginCommandBuffer(cb.handle(), &cmd_buf_info);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedExplicitReset) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "was destroyed or rerecorded");
|
|
|
|
// A pool we can reset in.
|
|
VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
|
|
VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
secondary.begin();
|
|
secondary.end();
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
|
|
// rerecording of secondary
|
|
secondary.reset(); // explicit reset here.
|
|
secondary.begin();
|
|
secondary.end();
|
|
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedNoReset) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "was destroyed or rerecorded");
|
|
|
|
// A pool we can reset in.
|
|
VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
|
|
VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
secondary.begin();
|
|
secondary.end();
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
|
|
// rerecording of secondary
|
|
secondary.begin(); // implicit reset in begin
|
|
secondary.end();
|
|
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CascadedInvalidation) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkEventCreateInfo eci = {VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, nullptr, 0};
|
|
VkEvent event;
|
|
vkCreateEvent(m_device->device(), &eci, nullptr, &event);
|
|
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
secondary.begin();
|
|
vkCmdSetEvent(secondary.handle(), event, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
|
|
secondary.end();
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_commandBuffer->end();
|
|
|
|
// destroying the event should invalidate both primary and secondary CB
|
|
vkDestroyEvent(m_device->device(), event, nullptr);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"UNASSIGNED-CoreValidation-DrawState-InvalidCommandBuffer-VkEvent");
|
|
m_commandBuffer->QueueCommandBuffer(false);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CommandBufferResetErrors) {
|
|
// Cause error due to Begin while recording CB
|
|
// Then cause 2 errors for attempting to reset CB w/o having
|
|
// VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT set for the pool from
|
|
// which CBs were allocated. Note that this bit is off by default.
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkBeginCommandBuffer-commandBuffer-00049");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Calls AllocateCommandBuffers
|
|
VkCommandBufferObj commandBuffer(m_device, m_commandPool);
|
|
|
|
// Force the failure by setting the Renderpass and Framebuffer fields with (fake) data
|
|
VkCommandBufferInheritanceInfo cmd_buf_hinfo = {};
|
|
cmd_buf_hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
|
|
VkCommandBufferBeginInfo cmd_buf_info = {};
|
|
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
cmd_buf_info.pNext = NULL;
|
|
cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
cmd_buf_info.pInheritanceInfo = &cmd_buf_hinfo;
|
|
|
|
// Begin CB to transition to recording state
|
|
vkBeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
|
|
// Can't re-begin. This should trigger error
|
|
vkBeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkResetCommandBuffer-commandBuffer-00046");
|
|
VkCommandBufferResetFlags flags = 0; // Don't care about flags for this test
|
|
// Reset attempt will trigger error due to incorrect CommandPool state
|
|
vkResetCommandBuffer(commandBuffer.handle(), flags);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkBeginCommandBuffer-commandBuffer-00050");
|
|
// Transition CB to RECORDED state
|
|
vkEndCommandBuffer(commandBuffer.handle());
|
|
// Now attempting to Begin will implicitly reset, which triggers error
|
|
vkBeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ClearColorAttachmentsOutsideRenderPass) {
|
|
// Call CmdClearAttachmentss outside of an active RenderPass
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdClearAttachments(): This call must be issued inside an active render pass");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
// Start no RenderPass
|
|
m_commandBuffer->begin();
|
|
|
|
VkClearAttachment color_attachment;
|
|
color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
color_attachment.clearValue.color.float32[0] = 0;
|
|
color_attachment.clearValue.color.float32[1] = 0;
|
|
color_attachment.clearValue.color.float32[2] = 0;
|
|
color_attachment.clearValue.color.float32[3] = 0;
|
|
color_attachment.colorAttachment = 0;
|
|
VkClearRect clear_rect = {{{0, 0}, {32, 32}}, 0, 1};
|
|
vkCmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ClearColorAttachmentsZeroLayercount) {
|
|
TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a layerCount of zero.");
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdClearAttachments-layerCount-01934");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
VkClearAttachment color_attachment;
|
|
color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
color_attachment.clearValue.color.float32[0] = 0;
|
|
color_attachment.clearValue.color.float32[1] = 0;
|
|
color_attachment.clearValue.color.float32[2] = 0;
|
|
color_attachment.clearValue.color.float32[3] = 0;
|
|
color_attachment.colorAttachment = 0;
|
|
VkClearRect clear_rect = {{{0, 0}, {32, 32}}};
|
|
vkCmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB) {
|
|
TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a primary command buffer (should only be secondary)");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
// An empty primary command buffer
|
|
VkCommandBufferObj cb(m_device, m_commandPool);
|
|
cb.begin();
|
|
cb.end();
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
|
|
VkCommandBuffer handle = cb.handle();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdExecuteCommands-pCommandBuffers-00088");
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &handle);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetUnexpectedError("All elements of pCommandBuffers must not be in the pending state");
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, InvalidVertexAttributeAlignment) {
|
|
TEST_DESCRIPTION("Check for proper aligment of attribAddress which depends on a bound pipeline and on a bound vertex buffer");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitViewport());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
const VkPipelineLayoutObj pipeline_layout(m_device);
|
|
|
|
struct VboEntry {
|
|
uint16_t input0[2];
|
|
uint32_t input1;
|
|
float input2[4];
|
|
};
|
|
|
|
const unsigned vbo_entry_count = 3;
|
|
const VboEntry vbo_data[vbo_entry_count] = {};
|
|
|
|
VkConstantBufferObj vbo(m_device, static_cast<int>(sizeof(VboEntry) * vbo_entry_count),
|
|
reinterpret_cast<const void *>(vbo_data), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
|
|
|
|
VkVertexInputBindingDescription input_binding;
|
|
input_binding.binding = 0;
|
|
input_binding.stride = sizeof(VboEntry);
|
|
input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
VkVertexInputAttributeDescription input_attribs[3];
|
|
|
|
input_attribs[0].binding = 0;
|
|
// Location switch between attrib[0] and attrib[1] is intentional
|
|
input_attribs[0].location = 1;
|
|
input_attribs[0].format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
|
|
input_attribs[0].offset = offsetof(VboEntry, input1);
|
|
|
|
input_attribs[1].binding = 0;
|
|
input_attribs[1].location = 0;
|
|
input_attribs[1].format = VK_FORMAT_R16G16_UNORM;
|
|
input_attribs[1].offset = offsetof(VboEntry, input0);
|
|
|
|
input_attribs[2].binding = 0;
|
|
input_attribs[2].location = 2;
|
|
input_attribs[2].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
|
input_attribs[2].offset = offsetof(VboEntry, input2);
|
|
|
|
char const *vsSource =
|
|
"#version 450\n"
|
|
"\n"
|
|
"layout(location = 0) in vec2 input0;"
|
|
"layout(location = 1) in vec4 input1;"
|
|
"layout(location = 2) in vec4 input2;"
|
|
"\n"
|
|
"void main(){\n"
|
|
" gl_Position = input1 + input2;\n"
|
|
" gl_Position.xy += input0;\n"
|
|
"}\n";
|
|
|
|
VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
|
|
|
|
VkPipelineObj pipe1(m_device);
|
|
pipe1.AddDefaultColorAttachment();
|
|
pipe1.AddShader(&vs);
|
|
pipe1.AddShader(&fs);
|
|
pipe1.AddVertexInputBindings(&input_binding, 1);
|
|
pipe1.AddVertexInputAttribs(&input_attribs[0], 3);
|
|
pipe1.SetViewport(m_viewports);
|
|
pipe1.SetScissor(m_scissors);
|
|
pipe1.CreateVKPipeline(pipeline_layout.handle(), renderPass());
|
|
|
|
input_binding.stride = 6;
|
|
|
|
VkPipelineObj pipe2(m_device);
|
|
pipe2.AddDefaultColorAttachment();
|
|
pipe2.AddShader(&vs);
|
|
pipe2.AddShader(&fs);
|
|
pipe2.AddVertexInputBindings(&input_binding, 1);
|
|
pipe2.AddVertexInputAttribs(&input_attribs[0], 3);
|
|
pipe2.SetViewport(m_viewports);
|
|
pipe2.SetScissor(m_scissors);
|
|
pipe2.CreateVKPipeline(pipeline_layout.handle(), renderPass());
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
// Test with invalid buffer offset
|
|
VkDeviceSize offset = 1;
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe1.handle());
|
|
vkCmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid attribAddress alignment for vertex attribute 0");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid attribAddress alignment for vertex attribute 1");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid attribAddress alignment for vertex attribute 2");
|
|
m_commandBuffer->Draw(1, 0, 0, 0);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Test with invalid buffer stride
|
|
offset = 0;
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2.handle());
|
|
vkCmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid attribAddress alignment for vertex attribute 0");
|
|
// Attribute[1] is aligned properly even with a wrong stride
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Invalid attribAddress alignment for vertex attribute 2");
|
|
m_commandBuffer->Draw(1, 0, 0, 0);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, NonSimultaneousSecondaryMarksPrimary) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
const char *simultaneous_use_message = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBufferSimultaneousUse";
|
|
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
secondary.begin();
|
|
secondary.end();
|
|
|
|
VkCommandBufferBeginInfo cbbi = {
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
|
nullptr,
|
|
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
|
|
nullptr,
|
|
};
|
|
|
|
m_commandBuffer->begin(&cbbi);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT, simultaneous_use_message);
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SimultaneousUseSecondaryTwoExecutes) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00092";
|
|
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
VkCommandBufferInheritanceInfo inh = {
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
|
|
nullptr,
|
|
};
|
|
VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh};
|
|
|
|
secondary.begin(&cbbi);
|
|
secondary.end();
|
|
|
|
m_commandBuffer->begin();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, simultaneous_use_message);
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SimultaneousUseSecondarySingleExecute) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// variation on previous test executing the same CB twice in the same
|
|
// CmdExecuteCommands call
|
|
|
|
const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00093";
|
|
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
VkCommandBufferInheritanceInfo inh = {
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
|
|
nullptr,
|
|
};
|
|
VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh};
|
|
|
|
secondary.begin(&cbbi);
|
|
secondary.end();
|
|
|
|
m_commandBuffer->begin();
|
|
VkCommandBuffer cbs[] = {secondary.handle(), secondary.handle()};
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, simultaneous_use_message);
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 2, cbs);
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SimultaneousUseOneShot) {
|
|
TEST_DESCRIPTION("Submit the same command buffer twice in one submit looking for simultaneous use and one time submit errors");
|
|
const char *simultaneous_use_message = "is already in use and is not marked for simultaneous use";
|
|
const char *one_shot_message = "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted";
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkCommandBuffer cmd_bufs[2];
|
|
VkCommandBufferAllocateInfo alloc_info;
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
alloc_info.pNext = NULL;
|
|
alloc_info.commandBufferCount = 2;
|
|
alloc_info.commandPool = m_commandPool->handle();
|
|
alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
vkAllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs);
|
|
|
|
VkCommandBufferBeginInfo cb_binfo;
|
|
cb_binfo.pNext = NULL;
|
|
cb_binfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
cb_binfo.pInheritanceInfo = VK_NULL_HANDLE;
|
|
cb_binfo.flags = 0;
|
|
vkBeginCommandBuffer(cmd_bufs[0], &cb_binfo);
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(cmd_bufs[0], 0, 1, &viewport);
|
|
vkEndCommandBuffer(cmd_bufs[0]);
|
|
VkCommandBuffer duplicates[2] = {cmd_bufs[0], cmd_bufs[0]};
|
|
|
|
VkSubmitInfo submit_info = {};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.commandBufferCount = 2;
|
|
submit_info.pCommandBuffers = duplicates;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, simultaneous_use_message);
|
|
vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
m_errorMonitor->VerifyFound();
|
|
vkQueueWaitIdle(m_device->m_queue);
|
|
|
|
// Set one time use and now look for one time submit
|
|
duplicates[0] = duplicates[1] = cmd_bufs[1];
|
|
cb_binfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
vkBeginCommandBuffer(cmd_bufs[1], &cb_binfo);
|
|
vkCmdSetViewport(cmd_bufs[1], 0, 1, &viewport);
|
|
vkEndCommandBuffer(cmd_bufs[1]);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, one_shot_message);
|
|
vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
m_errorMonitor->VerifyFound();
|
|
vkQueueWaitIdle(m_device->m_queue);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawTimeImageViewTypeMismatchWithPipeline) {
|
|
TEST_DESCRIPTION(
|
|
"Test that an error is produced when an image view type does not match the dimensionality declared in the shader");
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "requires an image view of type VK_IMAGE_VIEW_TYPE_3D");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
char const *fsSource =
|
|
"#version 450\n"
|
|
"\n"
|
|
"layout(set=0, binding=0) uniform sampler3D s;\n"
|
|
"layout(location=0) out vec4 color;\n"
|
|
"void main() {\n"
|
|
" color = texture(s, vec3(0));\n"
|
|
"}\n";
|
|
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
|
|
|
|
VkPipelineObj pipe(m_device);
|
|
pipe.AddShader(&vs);
|
|
pipe.AddShader(&fs);
|
|
pipe.AddDefaultColorAttachment();
|
|
|
|
VkTextureObj texture(m_device, nullptr);
|
|
VkSamplerObj sampler(m_device);
|
|
|
|
VkDescriptorSetObj descriptorSet(m_device);
|
|
descriptorSet.AppendSamplerTexture(&sampler, &texture);
|
|
descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
|
|
|
|
VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
|
|
m_commandBuffer->BindDescriptorSet(descriptorSet);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
// error produced here.
|
|
vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawTimeImageMultisampleMismatchWithPipeline) {
|
|
TEST_DESCRIPTION(
|
|
"Test that an error is produced when a multisampled images are consumed via singlesample images types in the shader, or "
|
|
"vice versa.");
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "requires bound image to have multiple samples");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
char const *fsSource =
|
|
"#version 450\n"
|
|
"\n"
|
|
"layout(set=0, binding=0) uniform sampler2DMS s;\n"
|
|
"layout(location=0) out vec4 color;\n"
|
|
"void main() {\n"
|
|
" color = texelFetch(s, ivec2(0), 0);\n"
|
|
"}\n";
|
|
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
|
|
|
|
VkPipelineObj pipe(m_device);
|
|
pipe.AddShader(&vs);
|
|
pipe.AddShader(&fs);
|
|
pipe.AddDefaultColorAttachment();
|
|
|
|
VkTextureObj texture(m_device, nullptr); // THIS LINE CAUSES CRASH ON MALI
|
|
VkSamplerObj sampler(m_device);
|
|
|
|
VkDescriptorSetObj descriptorSet(m_device);
|
|
descriptorSet.AppendSamplerTexture(&sampler, &texture);
|
|
descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
|
|
|
|
VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
|
|
m_commandBuffer->BindDescriptorSet(descriptorSet);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
// error produced here.
|
|
vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawTimeImageComponentTypeMismatchWithPipeline) {
|
|
TEST_DESCRIPTION(
|
|
"Test that an error is produced when the component type of an imageview disagrees with the type in the shader.");
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "SINT component type, but bound descriptor");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
char const *fsSource =
|
|
"#version 450\n"
|
|
"\n"
|
|
"layout(set=0, binding=0) uniform isampler2D s;\n"
|
|
"layout(location=0) out vec4 color;\n"
|
|
"void main() {\n"
|
|
" color = texelFetch(s, ivec2(0), 0);\n"
|
|
"}\n";
|
|
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
|
|
|
|
VkPipelineObj pipe(m_device);
|
|
pipe.AddShader(&vs);
|
|
pipe.AddShader(&fs);
|
|
pipe.AddDefaultColorAttachment();
|
|
|
|
VkTextureObj texture(m_device, nullptr); // UNORM texture by default, incompatible with isampler2D
|
|
VkSamplerObj sampler(m_device);
|
|
|
|
VkDescriptorSetObj descriptorSet(m_device);
|
|
descriptorSet.AppendSamplerTexture(&sampler, &texture);
|
|
descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
|
|
|
|
VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
|
|
m_commandBuffer->BindDescriptorSet(descriptorSet);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
// error produced here.
|
|
vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageLayerCountMismatch) {
|
|
TEST_DESCRIPTION(
|
|
"Try to copy between images with the source subresource having a different layerCount than the destination subresource");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images to copy between
|
|
VkImageObj src_image_obj(m_device);
|
|
VkImageObj dst_image_obj(m_device);
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 32;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 4;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
image_create_info.flags = 0;
|
|
|
|
src_image_obj.init(&image_create_info);
|
|
ASSERT_TRUE(src_image_obj.initialized());
|
|
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
dst_image_obj.init(&image_create_info);
|
|
ASSERT_TRUE(dst_image_obj.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
VkImageCopy copyRegion;
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.srcSubresource.mipLevel = 0;
|
|
copyRegion.srcSubresource.baseArrayLayer = 0;
|
|
copyRegion.srcSubresource.layerCount = 1;
|
|
copyRegion.srcOffset.x = 0;
|
|
copyRegion.srcOffset.y = 0;
|
|
copyRegion.srcOffset.z = 0;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.mipLevel = 0;
|
|
copyRegion.dstSubresource.baseArrayLayer = 0;
|
|
// Introduce failure by forcing the dst layerCount to differ from src
|
|
copyRegion.dstSubresource.layerCount = 3;
|
|
copyRegion.dstOffset.x = 0;
|
|
copyRegion.dstOffset.y = 0;
|
|
copyRegion.dstOffset.z = 0;
|
|
copyRegion.extent.width = 1;
|
|
copyRegion.extent.height = 1;
|
|
copyRegion.extent.depth = 1;
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-extent-00140");
|
|
m_commandBuffer->CopyImage(src_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CompressedImageMipCopyTests) {
|
|
TEST_DESCRIPTION("Image/Buffer copies for higher mip levels");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkPhysicalDeviceFeatures device_features = {};
|
|
ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
|
|
VkFormat compressed_format = VK_FORMAT_UNDEFINED;
|
|
if (device_features.textureCompressionBC) {
|
|
compressed_format = VK_FORMAT_BC3_SRGB_BLOCK;
|
|
} else if (device_features.textureCompressionETC2) {
|
|
compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
|
} else if (device_features.textureCompressionASTC_LDR) {
|
|
compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
|
} else {
|
|
printf("%s No compressed formats supported - CompressedImageMipCopyTests skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = compressed_format;
|
|
ci.extent = {32, 32, 1};
|
|
ci.mipLevels = 6;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkImageObj image(m_device);
|
|
image.init(&ci);
|
|
ASSERT_TRUE(image.initialized());
|
|
|
|
VkImageObj odd_image(m_device);
|
|
ci.extent = {31, 32, 1}; // Mips are [31,32] [15,16] [7,8] [3,4], [1,2] [1,1]
|
|
odd_image.init(&ci);
|
|
ASSERT_TRUE(odd_image.initialized());
|
|
|
|
// Allocate buffers
|
|
VkMemoryPropertyFlags reqs = 0;
|
|
VkBufferObj buffer_1024, buffer_64, buffer_16, buffer_8;
|
|
buffer_1024.init_as_src_and_dst(*m_device, 1024, reqs);
|
|
buffer_64.init_as_src_and_dst(*m_device, 64, reqs);
|
|
buffer_16.init_as_src_and_dst(*m_device, 16, reqs);
|
|
buffer_8.init_as_src_and_dst(*m_device, 8, reqs);
|
|
|
|
VkBufferImageCopy region = {};
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 0;
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageOffset = {0, 0, 0};
|
|
region.bufferOffset = 0;
|
|
|
|
// start recording
|
|
m_commandBuffer->begin();
|
|
|
|
// Mip level copies that work - 5 levels
|
|
m_errorMonitor->ExpectSuccess();
|
|
|
|
// Mip 0 should fit in 1k buffer - 1k texels @ 1b each
|
|
region.imageExtent = {32, 32, 1};
|
|
region.imageSubresource.mipLevel = 0;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_1024.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_1024.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
|
|
// Mip 2 should fit in 64b buffer - 64 texels @ 1b each
|
|
region.imageExtent = {8, 8, 1};
|
|
region.imageSubresource.mipLevel = 2;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
|
|
// Mip 3 should fit in 16b buffer - 16 texels @ 1b each
|
|
region.imageExtent = {4, 4, 1};
|
|
region.imageSubresource.mipLevel = 3;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
|
|
// Mip 4&5 should fit in 16b buffer with no complaint - 4 & 1 texels @ 1b each
|
|
region.imageExtent = {2, 2, 1};
|
|
region.imageSubresource.mipLevel = 4;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
|
|
region.imageExtent = {1, 1, 1};
|
|
region.imageSubresource.mipLevel = 5;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Buffer must accommodate a full compressed block, regardless of texel count
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_8.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-pRegions-00171");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_8.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Copy width < compressed block size, but not the full mip width
|
|
region.imageExtent = {1, 2, 1};
|
|
region.imageSubresource.mipLevel = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00207"); // width not a multiple of compressed block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00207"); // width not a multiple of compressed block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Copy height < compressed block size but not the full mip height
|
|
region.imageExtent = {2, 1, 1};
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00208"); // height not a multiple of compressed block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00208"); // height not a multiple of compressed block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Offsets must be multiple of compressed block size
|
|
region.imageOffset = {1, 1, 0};
|
|
region.imageExtent = {1, 1, 1};
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageOffset-00205"); // imageOffset not a multiple of block size
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageOffset-00205"); // imageOffset not a multiple of block size
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Offset + extent width = mip width - should succeed
|
|
region.imageOffset = {4, 4, 0};
|
|
region.imageExtent = {3, 4, 1};
|
|
region.imageSubresource.mipLevel = 2;
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Offset + extent width < mip width and not a multiple of block width - should fail
|
|
region.imageExtent = {3, 3, 1};
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00208"); // offset+extent not a multiple of block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00208"); // offset+extent not a multiple of block width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ImageBufferCopyTests) {
|
|
TEST_DESCRIPTION("Image to buffer and buffer to image tests");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Bail if any dimension of transfer granularity is 0.
|
|
auto index = m_device->graphics_queue_node_index_;
|
|
auto queue_family_properties = m_device->phy().queue_properties();
|
|
if ((queue_family_properties[index].minImageTransferGranularity.depth == 0) ||
|
|
(queue_family_properties[index].minImageTransferGranularity.width == 0) ||
|
|
(queue_family_properties[index].minImageTransferGranularity.height == 0)) {
|
|
printf("%s Subresource copies are disallowed when xfer granularity (x|y|z) is 0. Skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkImageObj image_64k(m_device); // 128^2 texels, 64k
|
|
VkImageObj image_16k(m_device); // 64^2 texels, 16k
|
|
VkImageObj image_16k_depth(m_device); // 64^2 texels, depth, 16k
|
|
VkImageObj ds_image_4D_1S(m_device); // 256^2 texels, 512kb (256k depth, 64k stencil, 192k pack)
|
|
VkImageObj ds_image_3D_1S(m_device); // 256^2 texels, 256kb (192k depth, 64k stencil)
|
|
VkImageObj ds_image_2D(m_device); // 256^2 texels, 128k (128k depth)
|
|
VkImageObj ds_image_1S(m_device); // 256^2 texels, 64k (64k stencil)
|
|
|
|
image_64k.Init(128, 128, 1, VK_FORMAT_R8G8B8A8_UINT,
|
|
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
image_16k.Init(64, 64, 1, VK_FORMAT_R8G8B8A8_UINT,
|
|
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(image_64k.initialized());
|
|
ASSERT_TRUE(image_16k.initialized());
|
|
|
|
// Verify all needed Depth/Stencil formats are supported
|
|
bool missing_ds_support = false;
|
|
VkFormatProperties props = {0, 0, 0};
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT_S8_UINT, &props);
|
|
missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D24_UNORM_S8_UINT, &props);
|
|
missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &props);
|
|
missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &props);
|
|
missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0);
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0;
|
|
missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0;
|
|
|
|
if (!missing_ds_support) {
|
|
image_16k_depth.Init(64, 64, 1, VK_FORMAT_D24_UNORM_S8_UINT,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(image_16k_depth.initialized());
|
|
|
|
ds_image_4D_1S.Init(
|
|
256, 256, 1, VK_FORMAT_D32_SFLOAT_S8_UINT,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(ds_image_4D_1S.initialized());
|
|
|
|
ds_image_3D_1S.Init(
|
|
256, 256, 1, VK_FORMAT_D24_UNORM_S8_UINT,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(ds_image_3D_1S.initialized());
|
|
|
|
ds_image_2D.Init(
|
|
256, 256, 1, VK_FORMAT_D16_UNORM,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(ds_image_2D.initialized());
|
|
|
|
ds_image_1S.Init(
|
|
256, 256, 1, VK_FORMAT_S8_UINT,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(ds_image_1S.initialized());
|
|
}
|
|
|
|
// Allocate buffers
|
|
VkBufferObj buffer_256k, buffer_128k, buffer_64k, buffer_16k;
|
|
VkMemoryPropertyFlags reqs = 0;
|
|
buffer_256k.init_as_src_and_dst(*m_device, 262144, reqs); // 256k
|
|
buffer_128k.init_as_src_and_dst(*m_device, 131072, reqs); // 128k
|
|
buffer_64k.init_as_src_and_dst(*m_device, 65536, reqs); // 64k
|
|
buffer_16k.init_as_src_and_dst(*m_device, 16384, reqs); // 16k
|
|
|
|
VkBufferImageCopy region = {};
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 0;
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageOffset = {0, 0, 0};
|
|
region.imageExtent = {64, 64, 1};
|
|
region.bufferOffset = 0;
|
|
|
|
// attempt copies before putting command buffer in recording state
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-commandBuffer-recording");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording");
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// start recording
|
|
m_commandBuffer->begin();
|
|
|
|
// successful copies
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
region.imageOffset.x = 16; // 16k copy, offset requires larger image
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
region.imageExtent.height = 78; // > 16k copy requires larger buffer & image
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
region.imageOffset.x = 0;
|
|
region.imageExtent.height = 64;
|
|
region.bufferOffset = 256; // 16k copy with buffer offset, requires larger buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// image/buffer too small (extent too large) on copy to image
|
|
region.imageExtent = {65, 64, 1};
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-pRegions-00172"); // image too small
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// image/buffer too small (offset) on copy to image
|
|
region.imageExtent = {64, 64, 1};
|
|
region.imageOffset = {0, 4, 0};
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-pRegions-00172"); // image too small
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// image/buffer too small on copy to buffer
|
|
region.imageExtent = {64, 64, 1};
|
|
region.imageOffset = {0, 0, 0};
|
|
region.bufferOffset = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // buffer too small
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
region.imageExtent = {64, 65, 1};
|
|
region.bufferOffset = 0;
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00182"); // image too small
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// buffer size OK but rowlength causes loose packing
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
|
|
region.imageExtent = {64, 64, 1};
|
|
region.bufferRowLength = 68;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// An extent with zero area should produce a warning, but no error
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_ERROR_BIT_EXT, "} has zero area");
|
|
region.imageExtent.width = 0;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// aspect bits
|
|
region.imageExtent = {64, 64, 1};
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 0;
|
|
if (!missing_ds_support) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-aspectMask-00212"); // more than 1 aspect bit set
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-aspectMask-00211"); // different mis-matched aspect
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-aspectMask-00211"); // mis-matched aspect
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
|
|
// Out-of-range mip levels should fail
|
|
region.imageSubresource.mipLevel = image_16k.create_info().mipLevels + 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00200");
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00182"); // unavoidable "region exceeds image bounds" for non-existent mip
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-imageSubresource-01701");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
|
|
m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00200");
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyBufferToImage-pRegions-00172"); // unavoidable "region exceeds image bounds" for non-existent mip
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.imageSubresource.mipLevel = 0;
|
|
|
|
// Out-of-range array layers should fail
|
|
region.imageSubresource.baseArrayLayer = image_16k.create_info().arrayLayers;
|
|
region.imageSubresource.layerCount = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704");
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-imageSubresource-01702");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.imageSubresource.baseArrayLayer = 0;
|
|
|
|
// Layout mismatch should fail
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189");
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Test Depth/Stencil copies
|
|
if (missing_ds_support) {
|
|
printf("%s Depth / Stencil formats unsupported - skipping D/S tests.\n", kSkipPrefix);
|
|
} else {
|
|
VkBufferImageCopy ds_region = {};
|
|
ds_region.bufferOffset = 0;
|
|
ds_region.bufferRowLength = 0;
|
|
ds_region.bufferImageHeight = 0;
|
|
ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
ds_region.imageSubresource.mipLevel = 0;
|
|
ds_region.imageSubresource.baseArrayLayer = 0;
|
|
ds_region.imageSubresource.layerCount = 1;
|
|
ds_region.imageOffset = {0, 0, 0};
|
|
ds_region.imageExtent = {256, 256, 1};
|
|
|
|
// Depth copies that should succeed
|
|
m_errorMonitor->ExpectSuccess(); // Extract 4b depth per texel, pack into 256k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_256k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
m_errorMonitor->ExpectSuccess(); // Extract 3b depth per texel, pack (loose) into 256k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_256k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
m_errorMonitor->ExpectSuccess(); // Copy 2b depth per texel, into 128k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_128k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Depth copies that should fail
|
|
ds_region.bufferOffset = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 4b depth per texel, pack into 256k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_256k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 3b depth per texel, pack (loose) into 256k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_256k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 2b depth per texel, into 128k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_128k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Stencil copies that should succeed
|
|
ds_region.bufferOffset = 0;
|
|
ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
|
|
m_errorMonitor->ExpectSuccess(); // Extract 1b stencil per texel, pack into 64k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_64k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
m_errorMonitor->ExpectSuccess(); // Extract 1b stencil per texel, pack into 64k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_64k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
m_errorMonitor->ExpectSuccess(); // Copy 1b depth per texel, into 64k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_64k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Stencil copies that should fail
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_16k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
|
|
ds_region.bufferRowLength = 260;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_64k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
ds_region.bufferRowLength = 0;
|
|
ds_region.bufferOffset = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 1b depth per texel, into 64k buffer
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
buffer_64k.handle(), 1, &ds_region);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
// Test compressed formats, if supported
|
|
VkPhysicalDeviceFeatures device_features = {};
|
|
ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
|
|
if (!(device_features.textureCompressionBC || device_features.textureCompressionETC2 ||
|
|
device_features.textureCompressionASTC_LDR)) {
|
|
printf("%s No compressed formats supported - block compression tests skipped.\n", kSkipPrefix);
|
|
} else {
|
|
VkImageObj image_16k_4x4comp(m_device); // 128^2 texels as 32^2 compressed (4x4) blocks, 16k
|
|
VkImageObj image_NPOT_4x4comp(m_device); // 130^2 texels as 33^2 compressed (4x4) blocks
|
|
if (device_features.textureCompressionBC) {
|
|
image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL,
|
|
0);
|
|
image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL,
|
|
0);
|
|
} else if (device_features.textureCompressionETC2) {
|
|
image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
} else {
|
|
image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
}
|
|
ASSERT_TRUE(image_16k_4x4comp.initialized());
|
|
|
|
// Just fits
|
|
m_errorMonitor->ExpectSuccess();
|
|
region.imageExtent = {128, 128, 1};
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// with offset, too big for buffer
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
|
|
region.bufferOffset = 16;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.bufferOffset = 0;
|
|
|
|
// extents that are not a multiple of compressed block size
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00207"); // extent width not a multiple of block size
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
region.imageExtent.width = 66;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.imageExtent.width = 128;
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(
|
|
VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkBufferImageCopy-imageExtent-00208"); // extent height not a multiple of block size
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
|
|
region.imageExtent.height = 2;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
region.imageExtent.height = 128;
|
|
|
|
// TODO: All available compressed formats are 2D, with block depth of 1. Unable to provoke VU_01277.
|
|
|
|
// non-multiple extents are allowed if at the far edge of a non-block-multiple image - these should pass
|
|
m_errorMonitor->ExpectSuccess();
|
|
region.imageExtent.width = 66;
|
|
region.imageOffset.x = 64;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
region.imageExtent.width = 16;
|
|
region.imageOffset.x = 0;
|
|
region.imageExtent.height = 2;
|
|
region.imageOffset.y = 128;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyNotFound();
|
|
region.imageOffset = {0, 0, 0};
|
|
|
|
// buffer offset must be a multiple of texel block size (16)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferOffset-00206");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferOffset-00193");
|
|
region.imageExtent = {64, 64, 1};
|
|
region.bufferOffset = 24;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// rowlength not a multiple of block width (4)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferRowLength-00203");
|
|
region.bufferOffset = 0;
|
|
region.bufferRowLength = 130;
|
|
region.bufferImageHeight = 0;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// imageheight not a multiple of block height (4)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferImageHeight-00204");
|
|
region.bufferRowLength = 0;
|
|
region.bufferImageHeight = 130;
|
|
vkCmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(),
|
|
1, ®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
}
|
|
|
|
TEST_F(VkLayerTest, MiscImageLayerTests) {
|
|
TEST_DESCRIPTION("Image-related tests that don't belong elsewhere");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// TODO: Ideally we should check if a format is supported, before using it.
|
|
VkImageObj image(m_device);
|
|
image.Init(128, 128, 1, VK_FORMAT_R16G16B16A16_UINT, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 64bpp
|
|
ASSERT_TRUE(image.initialized());
|
|
VkBufferObj buffer;
|
|
VkMemoryPropertyFlags reqs = 0;
|
|
buffer.init_as_src(*m_device, 128 * 128 * 8, reqs);
|
|
VkBufferImageCopy region = {};
|
|
region.bufferRowLength = 128;
|
|
region.bufferImageHeight = 128;
|
|
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
// layerCount can't be 0 - Expect MISMATCHED_IMAGE_ASPECT
|
|
region.imageSubresource.layerCount = 1;
|
|
region.imageExtent.height = 4;
|
|
region.imageExtent.width = 4;
|
|
region.imageExtent.depth = 1;
|
|
|
|
VkImageObj image2(m_device);
|
|
image2.Init(128, 128, 1, VK_FORMAT_R8G8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 16bpp
|
|
ASSERT_TRUE(image2.initialized());
|
|
VkBufferObj buffer2;
|
|
VkMemoryPropertyFlags reqs2 = 0;
|
|
buffer2.init_as_src(*m_device, 128 * 128 * 2, reqs2);
|
|
VkBufferImageCopy region2 = {};
|
|
region2.bufferRowLength = 128;
|
|
region2.bufferImageHeight = 128;
|
|
region2.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
// layerCount can't be 0 - Expect MISMATCHED_IMAGE_ASPECT
|
|
region2.imageSubresource.layerCount = 1;
|
|
region2.imageExtent.height = 4;
|
|
region2.imageExtent.width = 4;
|
|
region2.imageExtent.depth = 1;
|
|
m_commandBuffer->begin();
|
|
|
|
// Image must have offset.z of 0 and extent.depth of 1
|
|
// Introduce failure by setting imageExtent.depth to 0
|
|
region.imageExtent.depth = 0;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-srcImage-00201");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
region.imageExtent.depth = 1;
|
|
|
|
// Image must have offset.z of 0 and extent.depth of 1
|
|
// Introduce failure by setting imageOffset.z to 4
|
|
// Note: Also (unavoidably) triggers 'region exceeds image' #1228
|
|
region.imageOffset.z = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-srcImage-00201");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-imageOffset-00200");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyBufferToImage-pRegions-00172");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
region.imageOffset.z = 0;
|
|
// BufferOffset must be a multiple of the calling command's VkImage parameter's texel size
|
|
// Introduce failure by setting bufferOffset to 1 and 1/2 texels
|
|
region.bufferOffset = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferOffset-00193");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// BufferOffset must be a multiple of 4
|
|
// Introduce failure by setting bufferOffset to a value not divisible by 4
|
|
region2.bufferOffset = 6;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferOffset-00194");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer2.handle(), image2.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion2);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// BufferRowLength must be 0, or greater than or equal to the width member of imageExtent
|
|
region.bufferOffset = 0;
|
|
region.imageExtent.height = 128;
|
|
region.imageExtent.width = 128;
|
|
// Introduce failure by setting bufferRowLength > 0 but less than width
|
|
region.bufferRowLength = 64;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferRowLength-00195");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
|
|
region.bufferRowLength = 128;
|
|
// Introduce failure by setting bufferRowHeight > 0 but less than height
|
|
region.bufferImageHeight = 64;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferImageCopy-bufferImageHeight-00196");
|
|
vkCmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
|
|
®ion);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
region.bufferImageHeight = 128;
|
|
VkImageObj intImage1(m_device);
|
|
intImage1.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
|
|
intImage1.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
|
|
VkImageObj intImage2(m_device);
|
|
intImage2.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
|
|
intImage2.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
|
|
VkImageBlit blitRegion = {};
|
|
blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
blitRegion.srcSubresource.baseArrayLayer = 0;
|
|
blitRegion.srcSubresource.layerCount = 1;
|
|
blitRegion.srcSubresource.mipLevel = 0;
|
|
blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
blitRegion.dstSubresource.baseArrayLayer = 0;
|
|
blitRegion.dstSubresource.layerCount = 1;
|
|
blitRegion.dstSubresource.mipLevel = 0;
|
|
blitRegion.srcOffsets[0] = {128, 0, 0};
|
|
blitRegion.srcOffsets[1] = {128, 128, 1};
|
|
blitRegion.dstOffsets[0] = {0, 128, 0};
|
|
blitRegion.dstOffsets[1] = {128, 128, 1};
|
|
|
|
// Look for NULL-blit warning
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT,
|
|
"vkCmdBlitImage(): pRegions[0].srcOffsets specify a zero-volume area.");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT,
|
|
"vkCmdBlitImage(): pRegions[0].dstOffsets specify a zero-volume area.");
|
|
vkCmdBlitImage(m_commandBuffer->handle(), intImage1.handle(), intImage1.Layout(), intImage2.handle(), intImage2.Layout(), 1,
|
|
&blitRegion, VK_FILTER_LINEAR);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageTypeExtentMismatch) {
|
|
// Image copy tests where format type and extents don't match
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_1D;
|
|
ci.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
ci.extent = {32, 1, 1};
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
// Create 1D image
|
|
VkImageObj image_1D(m_device);
|
|
image_1D.init(&ci);
|
|
ASSERT_TRUE(image_1D.initialized());
|
|
|
|
// 2D image
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.extent = {32, 32, 1};
|
|
VkImageObj image_2D(m_device);
|
|
image_2D.init(&ci);
|
|
ASSERT_TRUE(image_2D.initialized());
|
|
|
|
// 3D image
|
|
ci.imageType = VK_IMAGE_TYPE_3D;
|
|
ci.extent = {32, 32, 8};
|
|
VkImageObj image_3D(m_device);
|
|
image_3D.init(&ci);
|
|
ASSERT_TRUE(image_3D.initialized());
|
|
|
|
// 2D image array
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.extent = {32, 32, 1};
|
|
ci.arrayLayers = 8;
|
|
VkImageObj image_2D_array(m_device);
|
|
image_2D_array.init(&ci);
|
|
ASSERT_TRUE(image_2D_array.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {32, 1, 1};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Sanity check
|
|
m_errorMonitor->ExpectSuccess();
|
|
m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// 1D texture w/ offset.y > 0. Source = VU 09c00124, dest = 09c00130
|
|
copy_region.srcOffset.y = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-00146");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun
|
|
m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset.y = 0;
|
|
copy_region.dstOffset.y = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-00152");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun
|
|
m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset.y = 0;
|
|
|
|
// 1D texture w/ extent.height > 1. Source = VU 09c00124, dest = 09c00130
|
|
copy_region.extent.height = 2;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-00146");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun
|
|
m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-00152");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun
|
|
m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.extent.height = 1;
|
|
|
|
// 1D texture w/ offset.z > 0. Source = VU 09c00df2, dest = 09c00df4
|
|
copy_region.srcOffset.z = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01785");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun
|
|
m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset.z = 0;
|
|
copy_region.dstOffset.z = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01786");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun
|
|
m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset.z = 0;
|
|
|
|
// 1D texture w/ extent.depth > 1. Source = VU 09c00df2, dest = 09c00df4
|
|
copy_region.extent.depth = 2;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01785");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst)
|
|
m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01786");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst)
|
|
m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.extent.depth = 1;
|
|
|
|
// 2D texture w/ offset.z > 0. Source = VU 09c00df6, dest = 09c00df8
|
|
copy_region.extent = {16, 16, 1};
|
|
copy_region.srcOffset.z = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01787");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src)
|
|
m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset.z = 0;
|
|
copy_region.dstOffset.z = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01788");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst)
|
|
m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset.z = 0;
|
|
|
|
// 3D texture accessing an array layer other than 0. VU 09c0011a
|
|
copy_region.extent = {4, 4, 1};
|
|
copy_region.srcSubresource.baseArrayLayer = 1;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-00141");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-srcSubresource-01698"); // also 'too many layers'
|
|
m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageTypeExtentMismatchMaintenance1) {
|
|
// Image copy tests where format type and extents don't match and the Maintenance1 extension is enabled
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
|
|
m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s Maintenance1 extension cannot be enabled, test skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
|
|
VkFormat image_format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
VkFormatProperties format_props;
|
|
// TODO: Remove this check if or when devsim handles extensions.
|
|
// The chosen format has mandatory support the transfer src and dst format features when Maitenance1 is enabled. However, our
|
|
// use of devsim and the mock ICD violate this guarantee.
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props);
|
|
if (!(format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) {
|
|
printf("%s Maintenance1 extension is not supported.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_1D;
|
|
ci.format = image_format;
|
|
ci.extent = {32, 1, 1};
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
// Create 1D image
|
|
VkImageObj image_1D(m_device);
|
|
image_1D.init(&ci);
|
|
ASSERT_TRUE(image_1D.initialized());
|
|
|
|
// 2D image
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.extent = {32, 32, 1};
|
|
VkImageObj image_2D(m_device);
|
|
image_2D.init(&ci);
|
|
ASSERT_TRUE(image_2D.initialized());
|
|
|
|
// 3D image
|
|
ci.imageType = VK_IMAGE_TYPE_3D;
|
|
ci.extent = {32, 32, 8};
|
|
VkImageObj image_3D(m_device);
|
|
image_3D.init(&ci);
|
|
ASSERT_TRUE(image_3D.initialized());
|
|
|
|
// 2D image array
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.extent = {32, 32, 1};
|
|
ci.arrayLayers = 8;
|
|
VkImageObj image_2D_array(m_device);
|
|
image_2D_array.init(&ci);
|
|
ASSERT_TRUE(image_2D_array.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {32, 1, 1};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Copy from layer not present
|
|
copy_region.srcSubresource.baseArrayLayer = 4;
|
|
copy_region.srcSubresource.layerCount = 6;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcSubresource-01698");
|
|
m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
|
|
// Copy to layer not present
|
|
copy_region.dstSubresource.baseArrayLayer = 1;
|
|
copy_region.dstSubresource.layerCount = 8;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-dstSubresource-01699");
|
|
m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageCompressedBlockAlignment) {
|
|
// Image copy tests on compressed images with block alignment errors
|
|
SetTargetApiVersion(VK_API_VERSION_1_1);
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Select a compressed format and verify support
|
|
VkPhysicalDeviceFeatures device_features = {};
|
|
ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
|
|
VkFormat compressed_format = VK_FORMAT_UNDEFINED;
|
|
if (device_features.textureCompressionBC) {
|
|
compressed_format = VK_FORMAT_BC3_SRGB_BLOCK;
|
|
} else if (device_features.textureCompressionETC2) {
|
|
compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
|
} else if (device_features.textureCompressionASTC_LDR) {
|
|
compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
|
}
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = compressed_format;
|
|
ci.extent = {64, 64, 1};
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkImageFormatProperties img_prop = {};
|
|
if (VK_SUCCESS != vkGetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), ci.format, ci.imageType, ci.tiling,
|
|
ci.usage, ci.flags, &img_prop)) {
|
|
printf("%s No compressed formats supported - CopyImageCompressedBlockAlignment skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
// Create images
|
|
VkImageObj image_1(m_device);
|
|
image_1.init(&ci);
|
|
ASSERT_TRUE(image_1.initialized());
|
|
|
|
ci.extent = {62, 62, 1}; // slightly smaller and not divisible by block size
|
|
VkImageObj image_2(m_device);
|
|
image_2.init(&ci);
|
|
ASSERT_TRUE(image_2.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {48, 48, 1};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Sanity check
|
|
m_errorMonitor->ExpectSuccess();
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
std::string vuid;
|
|
bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
|
|
(DeviceValidationVersion() >= VK_API_VERSION_1_1));
|
|
|
|
// Src, Dest offsets must be multiples of compressed block sizes {4, 4, 1}
|
|
// Image transfer granularity gets set to compressed block size, so an ITG error is also (unavoidably) triggered.
|
|
vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01727" : "VUID-VkImageCopy-srcOffset-00157";
|
|
copy_region.srcOffset = {2, 4, 0}; // source width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset = {12, 1, 0}; // source height
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
|
|
vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01731" : "VUID-VkImageCopy-dstOffset-00162";
|
|
copy_region.dstOffset = {1, 0, 0}; // dest width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset = {4, 1, 0}; // dest height
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Copy extent must be multiples of compressed block sizes {4, 4, 1} if not full width/height
|
|
vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01728" : "VUID-VkImageCopy-extent-00158";
|
|
copy_region.extent = {62, 60, 1}; // source width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01729" : "VUID-VkImageCopy-extent-00159";
|
|
copy_region.extent = {60, 62, 1}; // source height
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity
|
|
m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01732" : "VUID-VkImageCopy-extent-00163";
|
|
copy_region.extent = {62, 60, 1}; // dest width
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity
|
|
m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01733" : "VUID-VkImageCopy-extent-00164";
|
|
copy_region.extent = {60, 62, 1}; // dest height
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity
|
|
m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Note: "VUID-VkImageCopy-extent-00160", "VUID-VkImageCopy-extent-00165", "VUID-VkImageCopy-srcImage-01730",
|
|
// "VUID-VkImageCopy-dstImage-01734"
|
|
// There are currently no supported compressed formats with a block depth other than 1,
|
|
// so impossible to create a 'not a multiple' condition for depth.
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageSinglePlane422Alignment) {
|
|
// Image copy tests on single-plane _422 formats with block alignment errors
|
|
|
|
// Enable KHR multiplane req'd extensions
|
|
bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
|
|
VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
|
|
if (mp_extensions) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
|
|
if (mp_extensions) {
|
|
m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
|
|
// Select a _422 format and verify support
|
|
VkImageCreateInfo ci = {};
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = VK_FORMAT_G8B8G8R8_422_UNORM_KHR;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
// Verify formats
|
|
VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
|
bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
|
|
if (!supported) {
|
|
printf("%s Single-plane _422 image format not supported. Skipping test.\n", kSkipPrefix);
|
|
return; // Assume there's low ROI on searching for different mp formats
|
|
}
|
|
|
|
// Create images
|
|
ci.extent = {64, 64, 1};
|
|
VkImageObj image_422(m_device);
|
|
image_422.init(&ci);
|
|
ASSERT_TRUE(image_422.initialized());
|
|
|
|
ci.extent = {64, 64, 1};
|
|
ci.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
VkImageObj image_ucmp(m_device);
|
|
image_ucmp.init(&ci);
|
|
ASSERT_TRUE(image_ucmp.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {48, 48, 1};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Src offsets must be multiples of compressed block sizes
|
|
copy_region.srcOffset = {3, 4, 0}; // source offset x
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01727");
|
|
m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
|
|
// Dst offsets must be multiples of compressed block sizes
|
|
copy_region.dstOffset = {1, 0, 0};
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01731");
|
|
m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
// Copy extent must be multiples of compressed block sizes if not full width/height
|
|
copy_region.extent = {31, 60, 1}; // 422 source, extent.x
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01728");
|
|
m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// 422 dest, extent.x
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01732");
|
|
m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageMultiplaneAspectBits) {
|
|
// Image copy tests on multiplane images with aspect errors
|
|
|
|
// Enable KHR multiplane req'd extensions
|
|
bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
|
|
VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION);
|
|
if (mp_extensions) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
|
|
mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
|
|
if (mp_extensions) {
|
|
m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
|
|
m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
|
|
// Select multi-plane formats and verify support
|
|
VkFormat mp3_format = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR;
|
|
VkFormat mp2_format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR;
|
|
|
|
VkImageCreateInfo ci = {};
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = mp2_format;
|
|
ci.extent = {256, 256, 1};
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
// Verify formats
|
|
VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
|
bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
|
|
ci.format = VK_FORMAT_D24_UNORM_S8_UINT;
|
|
supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
|
|
ci.format = mp3_format;
|
|
supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
|
|
if (!supported) {
|
|
printf("%s Multiplane image formats or optimally tiled depth-stencil buffers not supported. Skipping test.\n",
|
|
kSkipPrefix);
|
|
return; // Assume there's low ROI on searching for different mp formats
|
|
}
|
|
|
|
// Create images
|
|
VkImageObj mp3_image(m_device);
|
|
mp3_image.init(&ci);
|
|
ASSERT_TRUE(mp3_image.initialized());
|
|
|
|
ci.format = mp2_format;
|
|
VkImageObj mp2_image(m_device);
|
|
mp2_image.init(&ci);
|
|
ASSERT_TRUE(mp2_image.initialized());
|
|
|
|
ci.format = VK_FORMAT_D24_UNORM_S8_UINT;
|
|
VkImageObj sp_image(m_device);
|
|
sp_image.init(&ci);
|
|
ASSERT_TRUE(sp_image.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {128, 128, 1};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImage-srcImage-00135");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01552");
|
|
m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImage-srcImage-00135");
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01553");
|
|
m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
|
|
m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImage-srcImage-00135");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01554");
|
|
m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyImage-srcImage-00135");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01555");
|
|
m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcImage-01556");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "dest image depth/stencil formats"); // also
|
|
m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstImage-01557");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "dest image depth/stencil formats"); // also
|
|
m_commandBuffer->CopyImage(sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageSrcSizeExceeded) {
|
|
// Image copy with source region specified greater than src image size
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create images with full mip chain
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_3D;
|
|
ci.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
ci.extent = {32, 32, 8};
|
|
ci.mipLevels = 6;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkImageObj src_image(m_device);
|
|
src_image.init(&ci);
|
|
ASSERT_TRUE(src_image.initialized());
|
|
|
|
// Dest image with one more mip level
|
|
ci.extent = {64, 64, 16};
|
|
ci.mipLevels = 7;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
VkImageObj dst_image(m_device);
|
|
dst_image.init(&ci);
|
|
ASSERT_TRUE(dst_image.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {32, 32, 8};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
m_errorMonitor->ExpectSuccess();
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Source exceeded in x-dim, VU 01202
|
|
copy_region.srcOffset.x = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-pRegions-00122"); // General "contained within" VU
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00144");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Source exceeded in y-dim, VU 01203
|
|
copy_region.srcOffset.x = 0;
|
|
copy_region.extent.height = 48;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-pRegions-00122");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00145");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Source exceeded in z-dim, VU 01204
|
|
copy_region.extent = {4, 4, 4};
|
|
copy_region.srcSubresource.mipLevel = 2;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-pRegions-00122");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-srcOffset-00147");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageDstSizeExceeded) {
|
|
// Image copy with dest region specified greater than dest image size
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create images with full mip chain
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_3D;
|
|
ci.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
ci.extent = {32, 32, 8};
|
|
ci.mipLevels = 6;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkImageObj dst_image(m_device);
|
|
dst_image.init(&ci);
|
|
ASSERT_TRUE(dst_image.initialized());
|
|
|
|
// Src image with one more mip level
|
|
ci.extent = {64, 64, 16};
|
|
ci.mipLevels = 7;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
VkImageObj src_image(m_device);
|
|
src_image.init(&ci);
|
|
ASSERT_TRUE(src_image.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copy_region;
|
|
copy_region.extent = {32, 32, 8};
|
|
copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copy_region.srcSubresource.mipLevel = 0;
|
|
copy_region.dstSubresource.mipLevel = 0;
|
|
copy_region.srcSubresource.baseArrayLayer = 0;
|
|
copy_region.dstSubresource.baseArrayLayer = 0;
|
|
copy_region.srcSubresource.layerCount = 1;
|
|
copy_region.dstSubresource.layerCount = 1;
|
|
copy_region.srcOffset = {0, 0, 0};
|
|
copy_region.dstOffset = {0, 0, 0};
|
|
|
|
m_errorMonitor->ExpectSuccess();
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
// Dest exceeded in x-dim, VU 01205
|
|
copy_region.dstOffset.x = 4;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdCopyImage-pRegions-00123"); // General "contained within" VU
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00150");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Dest exceeded in y-dim, VU 01206
|
|
copy_region.dstOffset.x = 0;
|
|
copy_region.extent.height = 48;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-pRegions-00123");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00151");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Dest exceeded in z-dim, VU 01207
|
|
copy_region.extent = {4, 4, 4};
|
|
copy_region.dstSubresource.mipLevel = 2;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-pRegions-00123");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-dstOffset-00153");
|
|
m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©_region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageFormatSizeMismatch) {
|
|
VkResult err;
|
|
bool pass;
|
|
|
|
// Create color images with different format sizes and try to copy between them
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00135");
|
|
|
|
SetTargetApiVersion(VK_API_VERSION_1_1);
|
|
ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
|
|
// Create two images of different types and try to copy between them
|
|
VkImage srcImage;
|
|
VkImage dstImage;
|
|
VkDeviceMemory srcMem;
|
|
VkDeviceMemory destMem;
|
|
VkMemoryRequirements memReqs;
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 32;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
image_create_info.flags = 0;
|
|
|
|
err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
// Introduce failure by creating second image with a different-sized format.
|
|
image_create_info.format = VK_FORMAT_R5G5B5A1_UNORM_PACK16;
|
|
VkFormatProperties properties;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_create_info.format, &properties);
|
|
if (properties.optimalTilingFeatures == 0) {
|
|
vkDestroyImage(m_device->device(), srcImage, NULL);
|
|
printf("%s Image format not supported; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
// Allocate memory
|
|
VkMemoryAllocateInfo memAlloc = {};
|
|
memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
memAlloc.pNext = NULL;
|
|
memAlloc.allocationSize = 0;
|
|
memAlloc.memoryTypeIndex = 0;
|
|
|
|
vkGetImageMemoryRequirements(m_device->device(), srcImage, &memReqs);
|
|
memAlloc.allocationSize = memReqs.size;
|
|
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
|
|
ASSERT_TRUE(pass);
|
|
err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
|
|
memAlloc.allocationSize = memReqs.size;
|
|
pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
|
|
ASSERT_TRUE(pass);
|
|
err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
|
|
ASSERT_VK_SUCCESS(err);
|
|
err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
|
|
ASSERT_VK_SUCCESS(err);
|
|
|
|
m_commandBuffer->begin();
|
|
VkImageCopy copyRegion;
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.srcSubresource.mipLevel = 0;
|
|
copyRegion.srcSubresource.baseArrayLayer = 0;
|
|
copyRegion.srcSubresource.layerCount = 1;
|
|
copyRegion.srcOffset.x = 0;
|
|
copyRegion.srcOffset.y = 0;
|
|
copyRegion.srcOffset.z = 0;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.mipLevel = 0;
|
|
copyRegion.dstSubresource.baseArrayLayer = 0;
|
|
copyRegion.dstSubresource.layerCount = 1;
|
|
copyRegion.dstOffset.x = 0;
|
|
copyRegion.dstOffset.y = 0;
|
|
copyRegion.dstOffset.z = 0;
|
|
copyRegion.extent.width = 1;
|
|
copyRegion.extent.height = 1;
|
|
copyRegion.extent.depth = 1;
|
|
m_commandBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkDestroyImage(m_device->device(), dstImage, NULL);
|
|
vkFreeMemory(m_device->device(), destMem, NULL);
|
|
|
|
// Copy to multiplane image with mismatched sizes
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00135");
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
|
|
ci.extent = {32, 32, 1};
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_LINEAR;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
|
bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features);
|
|
bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
|
|
(DeviceValidationVersion() >= VK_API_VERSION_1_1));
|
|
if (!supported || !ycbcr) {
|
|
printf("%s Image format not supported; skipped multiplanar copy test.\n", kSkipPrefix);
|
|
vkDestroyImage(m_device->device(), srcImage, NULL);
|
|
vkFreeMemory(m_device->device(), srcMem, NULL);
|
|
return;
|
|
}
|
|
|
|
VkImageObj mpImage(m_device);
|
|
mpImage.init(&ci);
|
|
ASSERT_TRUE(mpImage.initialized());
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
|
|
vkResetCommandBuffer(m_commandBuffer->handle(), 0);
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, mpImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkDestroyImage(m_device->device(), srcImage, NULL);
|
|
vkFreeMemory(m_device->device(), srcMem, NULL);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageDepthStencilFormatMismatch) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
auto depth_format = FindSupportedDepthStencilFormat(gpu());
|
|
if (!depth_format) {
|
|
printf("%s Couldn't depth stencil image format.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkFormatProperties properties;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
|
|
if (properties.optimalTilingFeatures == 0) {
|
|
printf("%s Image format not supported; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkImageObj srcImage(m_device);
|
|
srcImage.Init(32, 32, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL);
|
|
ASSERT_TRUE(srcImage.initialized());
|
|
VkImageObj dstImage(m_device);
|
|
dstImage.Init(32, 32, 1, depth_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL);
|
|
ASSERT_TRUE(dstImage.initialized());
|
|
|
|
// Create two images of different types and try to copy between them
|
|
|
|
m_commandBuffer->begin();
|
|
VkImageCopy copyRegion;
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copyRegion.srcSubresource.mipLevel = 0;
|
|
copyRegion.srcSubresource.baseArrayLayer = 0;
|
|
copyRegion.srcSubresource.layerCount = 1;
|
|
copyRegion.srcOffset.x = 0;
|
|
copyRegion.srcOffset.y = 0;
|
|
copyRegion.srcOffset.z = 0;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copyRegion.dstSubresource.mipLevel = 0;
|
|
copyRegion.dstSubresource.baseArrayLayer = 0;
|
|
copyRegion.dstSubresource.layerCount = 1;
|
|
copyRegion.dstOffset.x = 0;
|
|
copyRegion.dstOffset.y = 0;
|
|
copyRegion.dstOffset.z = 0;
|
|
copyRegion.extent.width = 1;
|
|
copyRegion.extent.height = 1;
|
|
copyRegion.extent.depth = 1;
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdCopyImage called with unmatched source and dest image depth");
|
|
m_commandBuffer->CopyImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageSampleCountMismatch) {
|
|
TEST_DESCRIPTION("Image copies with sample count mis-matches");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
VkImageFormatProperties image_format_properties;
|
|
vkGetPhysicalDeviceImageFormatProperties(gpu(), VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
|
|
&image_format_properties);
|
|
|
|
if ((0 == (VK_SAMPLE_COUNT_2_BIT & image_format_properties.sampleCounts)) ||
|
|
(0 == (VK_SAMPLE_COUNT_4_BIT & image_format_properties.sampleCounts))) {
|
|
printf("%s Image multi-sample support not found; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkImageCreateInfo ci;
|
|
ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
ci.pNext = NULL;
|
|
ci.flags = 0;
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
ci.extent = {128, 128, 1};
|
|
ci.mipLevels = 1;
|
|
ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.queueFamilyIndexCount = 0;
|
|
ci.pQueueFamilyIndices = NULL;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
|
|
VkImageObj image1(m_device);
|
|
image1.init(&ci);
|
|
ASSERT_TRUE(image1.initialized());
|
|
|
|
ci.samples = VK_SAMPLE_COUNT_2_BIT;
|
|
VkImageObj image2(m_device);
|
|
image2.init(&ci);
|
|
ASSERT_TRUE(image2.initialized());
|
|
|
|
ci.samples = VK_SAMPLE_COUNT_4_BIT;
|
|
VkImageObj image4(m_device);
|
|
image4.init(&ci);
|
|
ASSERT_TRUE(image4.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
VkImageCopy copyRegion;
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.srcSubresource.mipLevel = 0;
|
|
copyRegion.srcSubresource.baseArrayLayer = 0;
|
|
copyRegion.srcSubresource.layerCount = 1;
|
|
copyRegion.srcOffset = {0, 0, 0};
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.mipLevel = 0;
|
|
copyRegion.dstSubresource.baseArrayLayer = 0;
|
|
copyRegion.dstSubresource.layerCount = 1;
|
|
copyRegion.dstOffset = {0, 0, 0};
|
|
copyRegion.extent = {128, 128, 1};
|
|
|
|
// Copy a single sample image to/from a multi-sample image
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00136");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), image1.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00136");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image1.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Copy between multi-sample images with different sample counts
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00136");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdCopyImage-srcImage-00136");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), image4.handle(), VK_IMAGE_LAYOUT_GENERAL, image2.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CopyImageAspectMismatch) {
|
|
TEST_DESCRIPTION("Image copies with aspect mask errors");
|
|
SetTargetApiVersion(VK_API_VERSION_1_1);
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
auto ds_format = FindSupportedDepthStencilFormat(gpu());
|
|
if (!ds_format) {
|
|
printf("%s Couldn't find depth stencil format.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
VkFormatProperties properties;
|
|
vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
|
|
if (properties.optimalTilingFeatures == 0) {
|
|
printf("%s Image format VK_FORMAT_D32_SFLOAT not supported; skipped.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
VkImageObj color_image(m_device), ds_image(m_device), depth_image(m_device);
|
|
color_image.Init(128, 128, 1, VK_FORMAT_R32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
|
|
depth_image.Init(128, 128, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ds_image.Init(128, 128, 1, ds_format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
|
VK_IMAGE_TILING_OPTIMAL, 0);
|
|
ASSERT_TRUE(color_image.initialized());
|
|
ASSERT_TRUE(depth_image.initialized());
|
|
ASSERT_TRUE(ds_image.initialized());
|
|
|
|
VkImageCopy copyRegion;
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copyRegion.srcSubresource.mipLevel = 0;
|
|
copyRegion.srcSubresource.baseArrayLayer = 0;
|
|
copyRegion.srcSubresource.layerCount = 1;
|
|
copyRegion.srcOffset = {0, 0, 0};
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copyRegion.dstSubresource.mipLevel = 0;
|
|
copyRegion.dstSubresource.baseArrayLayer = 0;
|
|
copyRegion.dstSubresource.layerCount = 1;
|
|
copyRegion.dstOffset = {64, 0, 0};
|
|
copyRegion.extent = {64, 128, 1};
|
|
|
|
// Submitting command before command buffer is in recording state
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"You must call vkBeginCommandBuffer"); // "VUID-vkCmdCopyImage-commandBuffer-recording");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
// Src and dest aspect masks don't match
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
|
|
bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
|
|
(DeviceValidationVersion() >= VK_API_VERSION_1_1));
|
|
std::string vuid = (ycbcr ? "VUID-VkImageCopy-srcImage-01551" : "VUID-VkImageCopy-aspectMask-00137");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
vkCmdCopyImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, ds_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
|
|
// Illegal combinations of aspect bits
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageSubresourceLayers-aspectMask-00167");
|
|
// These aspect/format mismatches are redundant but unavoidable here
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-aspectMask-00142");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
// same test for dstSubresource
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageSubresourceLayers-aspectMask-00167");
|
|
// These aspect/format mismatches are redundant but unavoidable here
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-aspectMask-00143");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Metadata aspect is illegal
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageSubresourceLayers-aspectMask-00168");
|
|
// These aspect/format mismatches are redundant but unavoidable here
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
// same test for dstSubresource
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageSubresourceLayers-aspectMask-00168");
|
|
// These aspect/format mismatches are redundant but unavoidable here
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, vuid);
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
|
|
// Aspect mask doesn't match source image format
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-aspectMask-00142");
|
|
// Again redundant but unavoidable
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "unmatched source and dest image depth/stencil formats");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Aspect mask doesn't match dest image format
|
|
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkImageCopy-aspectMask-00143");
|
|
// Again redundant but unavoidable
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "unmatched source and dest image depth/stencil formats");
|
|
vkCmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
|
|
VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveImageLowSampleCount) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdResolveImage called with source sample count less than 2.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of sample count 1 and try to Resolve between them
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 1;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
image_create_info.flags = 0;
|
|
|
|
VkImageObj srcImage(m_device);
|
|
srcImage.init(&image_create_info);
|
|
ASSERT_TRUE(srcImage.initialized());
|
|
|
|
VkImageObj dstImage(m_device);
|
|
dstImage.init(&image_create_info);
|
|
ASSERT_TRUE(dstImage.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
&resolveRegion);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveImageHighSampleCount) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdResolveImage called with dest sample count greater than 1.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of sample count 4 and try to Resolve between them
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 1;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_4_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.usage =
|
|
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
image_create_info.flags = 0;
|
|
|
|
VkImageObj srcImage(m_device);
|
|
srcImage.init(&image_create_info);
|
|
ASSERT_TRUE(srcImage.initialized());
|
|
|
|
VkImageObj dstImage(m_device);
|
|
dstImage.init(&image_create_info);
|
|
ASSERT_TRUE(dstImage.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
// Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
|
|
// VK_IMAGE_LAYOUT_UNDEFINED = 0,
|
|
// VK_IMAGE_LAYOUT_GENERAL = 1,
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
&resolveRegion);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveImageFormatMismatch) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT,
|
|
"vkCmdResolveImage called with unmatched source and dest formats.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of different types and try to copy between them
|
|
VkImageObj srcImage(m_device);
|
|
VkImageObj dstImage(m_device);
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 1;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_2_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
image_create_info.flags = 0;
|
|
srcImage.init(&image_create_info);
|
|
|
|
// Set format to something other than source image
|
|
image_create_info.format = VK_FORMAT_R32_SFLOAT;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
dstImage.init(&image_create_info);
|
|
|
|
m_commandBuffer->begin();
|
|
// Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
|
|
// VK_IMAGE_LAYOUT_UNDEFINED = 0,
|
|
// VK_IMAGE_LAYOUT_GENERAL = 1,
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
&resolveRegion);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveImageTypeMismatch) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT,
|
|
"vkCmdResolveImage called with unmatched source and dest image types.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of different types and try to copy between them
|
|
VkImageObj srcImage(m_device);
|
|
VkImageObj dstImage(m_device);
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 1;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_2_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
image_create_info.flags = 0;
|
|
srcImage.init(&image_create_info);
|
|
|
|
image_create_info.imageType = VK_IMAGE_TYPE_1D;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
dstImage.init(&image_create_info);
|
|
|
|
m_commandBuffer->begin();
|
|
// Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest?
|
|
// VK_IMAGE_LAYOUT_UNDEFINED = 0,
|
|
// VK_IMAGE_LAYOUT_GENERAL = 1,
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
|
|
&resolveRegion);
|
|
m_commandBuffer->end();
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveImageLayoutMismatch) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of different types and try to copy between them
|
|
VkImageObj srcImage(m_device);
|
|
VkImageObj dstImage(m_device);
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 32;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_2_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_create_info.usage =
|
|
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.flags = 0;
|
|
srcImage.init(&image_create_info);
|
|
ASSERT_TRUE(srcImage.initialized());
|
|
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
dstImage.init(&image_create_info);
|
|
ASSERT_TRUE(dstImage.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
// source image must have valid contents before resolve
|
|
VkClearColorValue clear_color = {{0, 0, 0, 0}};
|
|
VkImageSubresourceRange subresource = {};
|
|
subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
subresource.layerCount = 1;
|
|
subresource.levelCount = 1;
|
|
srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource);
|
|
srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
|
|
dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
// source image layout mismatch
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-srcImageLayout-00260");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
// dst image layout mismatch
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-dstImageLayout-00262");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), VK_IMAGE_LAYOUT_GENERAL,
|
|
1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ResolveInvalidSubresource) {
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
// Create two images of different types and try to copy between them
|
|
VkImageObj srcImage(m_device);
|
|
VkImageObj dstImage(m_device);
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 32;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_2_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_create_info.usage =
|
|
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.flags = 0;
|
|
srcImage.init(&image_create_info);
|
|
ASSERT_TRUE(srcImage.initialized());
|
|
|
|
// Note: Some implementations expect color attachment usage for any
|
|
// multisample surface
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
dstImage.init(&image_create_info);
|
|
ASSERT_TRUE(dstImage.initialized());
|
|
|
|
m_commandBuffer->begin();
|
|
// source image must have valid contents before resolve
|
|
VkClearColorValue clear_color = {{0, 0, 0, 0}};
|
|
VkImageSubresourceRange subresource = {};
|
|
subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
subresource.layerCount = 1;
|
|
subresource.levelCount = 1;
|
|
srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource);
|
|
srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
|
|
dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
|
|
VkImageResolve resolveRegion;
|
|
resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
resolveRegion.srcSubresource.layerCount = 1;
|
|
resolveRegion.srcOffset.x = 0;
|
|
resolveRegion.srcOffset.y = 0;
|
|
resolveRegion.srcOffset.z = 0;
|
|
resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
resolveRegion.dstSubresource.layerCount = 1;
|
|
resolveRegion.dstOffset.x = 0;
|
|
resolveRegion.dstOffset.y = 0;
|
|
resolveRegion.dstOffset.z = 0;
|
|
resolveRegion.extent.width = 1;
|
|
resolveRegion.extent.height = 1;
|
|
resolveRegion.extent.depth = 1;
|
|
// invalid source mip level
|
|
resolveRegion.srcSubresource.mipLevel = image_create_info.mipLevels;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-srcSubresource-01709");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
resolveRegion.srcSubresource.mipLevel = 0;
|
|
// invalid dest mip level
|
|
resolveRegion.dstSubresource.mipLevel = image_create_info.mipLevels;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-dstSubresource-01710");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
resolveRegion.dstSubresource.mipLevel = 0;
|
|
// invalid source array layer range
|
|
resolveRegion.srcSubresource.baseArrayLayer = image_create_info.arrayLayers;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-srcSubresource-01711");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
resolveRegion.srcSubresource.baseArrayLayer = 0;
|
|
// invalid dest array layer range
|
|
resolveRegion.dstSubresource.baseArrayLayer = image_create_info.arrayLayers;
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResolveImage-dstSubresource-01712");
|
|
m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(),
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion);
|
|
m_errorMonitor->VerifyFound();
|
|
resolveRegion.dstSubresource.baseArrayLayer = 0;
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ClearImageErrors) {
|
|
TEST_DESCRIPTION("Call ClearColorImage w/ a depth|stencil image and ClearDepthStencilImage with a color image.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
// Color image
|
|
VkClearColorValue clear_color;
|
|
memset(clear_color.uint32, 0, sizeof(uint32_t) * 4);
|
|
const VkFormat color_format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
const int32_t img_width = 32;
|
|
const int32_t img_height = 32;
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = color_format;
|
|
image_create_info.extent.width = img_width;
|
|
image_create_info.extent.height = img_height;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
|
|
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
|
|
vk_testing::Image color_image_no_transfer;
|
|
color_image_no_transfer.init(*m_device, image_create_info);
|
|
|
|
image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
vk_testing::Image color_image;
|
|
color_image.init(*m_device, image_create_info);
|
|
|
|
const VkImageSubresourceRange color_range = vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_COLOR_BIT);
|
|
|
|
// Depth/Stencil image
|
|
VkClearDepthStencilValue clear_value = {0};
|
|
VkImageCreateInfo ds_image_create_info = vk_testing::Image::create_info();
|
|
ds_image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
ds_image_create_info.format = VK_FORMAT_D16_UNORM;
|
|
ds_image_create_info.extent.width = 64;
|
|
ds_image_create_info.extent.height = 64;
|
|
ds_image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ds_image_create_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
|
|
vk_testing::Image ds_image;
|
|
ds_image.init(*m_device, ds_image_create_info);
|
|
|
|
const VkImageSubresourceRange ds_range = vk_testing::Image::subresource_range(ds_image_create_info, VK_IMAGE_ASPECT_DEPTH_BIT);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "vkCmdClearColorImage called with depth/stencil image.");
|
|
|
|
vkCmdClearColorImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1, &color_range);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdClearColorImage called with image created without VK_IMAGE_USAGE_TRANSFER_DST_BIT");
|
|
|
|
vkCmdClearColorImage(m_commandBuffer->handle(), color_image_no_transfer.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1,
|
|
&color_range);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Call CmdClearDepthStencilImage with color image
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdClearDepthStencilImage called without a depth/stencil image.");
|
|
|
|
vkCmdClearDepthStencilImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_value,
|
|
1, &ds_range);
|
|
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, CommandQueueFlags) {
|
|
TEST_DESCRIPTION(
|
|
"Allocate a command buffer on a queue that does not support graphics and try to issue a graphics-only command");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT);
|
|
if (queueFamilyIndex == UINT32_MAX) {
|
|
printf("%s Non-graphics queue family not found; skipped.\n", kSkipPrefix);
|
|
return;
|
|
} else {
|
|
// Create command pool on a non-graphics queue
|
|
VkCommandPoolObj command_pool(m_device, queueFamilyIndex);
|
|
|
|
// Setup command buffer on pool
|
|
VkCommandBufferObj command_buffer(m_device, &command_pool);
|
|
command_buffer.begin();
|
|
|
|
// Issue a graphics only command
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-commandBuffer-cmdpool");
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
command_buffer.SetViewport(0, 1, &viewport);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ExecuteUnrecordedSecondaryCB) {
|
|
TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB in the initial state");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
// never record secondary
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdExecuteCommands-pCommandBuffers-00089");
|
|
m_commandBuffer->begin();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ExecuteSecondaryCBWithLayoutMismatch) {
|
|
TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB with incorrect initial layout.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
|
|
|
|
VkImageCreateInfo image_create_info = {};
|
|
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_create_info.pNext = NULL;
|
|
image_create_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM;
|
|
image_create_info.extent.width = 32;
|
|
image_create_info.extent.height = 1;
|
|
image_create_info.extent.depth = 1;
|
|
image_create_info.mipLevels = 1;
|
|
image_create_info.arrayLayers = 1;
|
|
image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
image_create_info.flags = 0;
|
|
|
|
VkImageSubresource image_sub = VkImageObj::subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0);
|
|
VkImageSubresourceRange image_sub_range = VkImageObj::subresource_range(image_sub);
|
|
|
|
VkImageObj image(m_device);
|
|
image.init(&image_create_info);
|
|
ASSERT_TRUE(image.initialized());
|
|
VkImageMemoryBarrier image_barrier =
|
|
image.image_memory_barrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, image_sub_range);
|
|
|
|
auto pipeline = [&image_barrier](const VkCommandBufferObj &cb, VkImageLayout old_layout, VkImageLayout new_layout) {
|
|
image_barrier.oldLayout = old_layout;
|
|
image_barrier.newLayout = new_layout;
|
|
vkCmdPipelineBarrier(cb.handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0,
|
|
nullptr, 1, &image_barrier);
|
|
};
|
|
|
|
// Validate that mismatched use of image layout in secondary command buffer is caught at record time
|
|
VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
secondary.begin();
|
|
pipeline(secondary, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
secondary.end();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "UNASSIGNED-vkCmdExecuteCommands-commandBuffer-00001");
|
|
m_commandBuffer->begin();
|
|
pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Validate that we've tracked the changes from the secondary CB correctly
|
|
m_errorMonitor->ExpectSuccess();
|
|
pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL);
|
|
m_errorMonitor->VerifyNotFound();
|
|
m_commandBuffer->end();
|
|
|
|
m_commandBuffer->reset();
|
|
secondary.reset();
|
|
|
|
// Validate that UNDEFINED doesn't false positive on us
|
|
secondary.begin();
|
|
pipeline(secondary, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
secondary.end();
|
|
m_commandBuffer->begin();
|
|
pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
m_errorMonitor->ExpectSuccess();
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
|
|
m_errorMonitor->VerifyNotFound();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SetDynViewportParamTests) {
|
|
TEST_DESCRIPTION("Test parameters of vkCmdSetViewport without multiViewport feature");
|
|
|
|
SetTargetApiVersion(VK_API_VERSION_1_1);
|
|
VkPhysicalDeviceFeatures features{};
|
|
ASSERT_NO_FATAL_FAILURE(Init(&features));
|
|
|
|
const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0};
|
|
const VkViewport viewports[] = {vp, vp};
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
// array tests
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01224");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 1, 1, viewports);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-arraylength");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-01225");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 2, viewports);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01224");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-01225");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 1, 2, viewports);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-pViewports-parameter");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// core viewport tests
|
|
using std::vector;
|
|
struct TestCase {
|
|
VkViewport vp;
|
|
std::string veid;
|
|
};
|
|
|
|
// not necessarily boundary values (unspecified cast rounding), but guaranteed to be over limit
|
|
const auto one_past_max_w = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[0]));
|
|
const auto one_past_max_h = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[1]));
|
|
|
|
const auto min_bound = m_device->props.limits.viewportBoundsRange[0];
|
|
const auto max_bound = m_device->props.limits.viewportBoundsRange[1];
|
|
const auto one_before_min_bounds = NearestSmaller(min_bound);
|
|
const auto one_past_max_bounds = NearestGreater(max_bound);
|
|
|
|
const auto below_zero = NearestSmaller(0.0f);
|
|
const auto past_one = NearestGreater(1.0f);
|
|
|
|
vector<TestCase> test_cases = {
|
|
{{0.0, 0.0, 0.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"},
|
|
{{0.0, 0.0, one_past_max_w, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01771"},
|
|
{{0.0, 0.0, NAN, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"},
|
|
{{0.0, 0.0, 64.0, one_past_max_h, 0.0, 1.0}, "VUID-VkViewport-height-01773"},
|
|
{{one_before_min_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"},
|
|
{{one_past_max_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"},
|
|
{{NAN, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"},
|
|
{{0.0, one_before_min_bounds, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"},
|
|
{{0.0, NAN, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"},
|
|
{{max_bound, 0.0, 1.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"},
|
|
{{0.0, max_bound, 64.0, 1.0, 0.0, 1.0}, "VUID-VkViewport-y-01233"},
|
|
{{0.0, 0.0, 64.0, 64.0, below_zero, 1.0}, "VUID-VkViewport-minDepth-01234"},
|
|
{{0.0, 0.0, 64.0, 64.0, past_one, 1.0}, "VUID-VkViewport-minDepth-01234"},
|
|
{{0.0, 0.0, 64.0, 64.0, NAN, 1.0}, "VUID-VkViewport-minDepth-01234"},
|
|
{{0.0, 0.0, 64.0, 64.0, 0.0, below_zero}, "VUID-VkViewport-maxDepth-01235"},
|
|
{{0.0, 0.0, 64.0, 64.0, 0.0, past_one}, "VUID-VkViewport-maxDepth-01235"},
|
|
{{0.0, 0.0, 64.0, 64.0, 0.0, NAN}, "VUID-VkViewport-maxDepth-01235"},
|
|
};
|
|
|
|
if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
|
|
test_cases.push_back({{0.0, 0.0, 64.0, 0.0, 0.0, 1.0}, "VUID-VkViewport-height-01772"});
|
|
test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01772"});
|
|
} else {
|
|
test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01773"});
|
|
}
|
|
|
|
for (const auto &test_case : test_cases) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, test_case.veid);
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &test_case.vp);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SetDynViewportParamMaintenance1Tests) {
|
|
TEST_DESCRIPTION("Verify errors are detected on misuse of SetViewport with a negative viewport extension enabled.");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
|
|
if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
|
|
m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s VK_KHR_maintenance1 extension not supported -- skipping test\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
|
|
NegHeightViewportTests(m_device, m_commandBuffer, m_errorMonitor);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SetDynViewportParamMultiviewportTests) {
|
|
TEST_DESCRIPTION("Test parameters of vkCmdSetViewport with multiViewport feature enabled");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
if (!m_device->phy().features().multiViewport) {
|
|
printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
const auto max_viewports = m_device->props.limits.maxViewports;
|
|
const uint32_t too_many_viewports = 65536 + 1; // let's say this is too much to allocate pViewports for
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-arraylength");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-pViewports-parameter");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, max_viewports, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
if (max_viewports >= too_many_viewports) {
|
|
printf(
|
|
"%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping "
|
|
"part of "
|
|
"test.\n",
|
|
kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0};
|
|
const std::vector<VkViewport> viewports(max_viewports + 1, vp);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01223");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, max_viewports + 1, viewports.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01223");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), max_viewports, 1, viewports.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01223");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 1, max_viewports, viewports.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-arraylength");
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports.data());
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, BadRenderPassScopeSecondaryCmdBuffer) {
|
|
TEST_DESCRIPTION(
|
|
"Test secondary buffers executed in wrong render pass scope wrt VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
VkCommandBufferObj sec_cmdbuff_inside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
VkCommandBufferObj sec_cmdbuff_outside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
|
|
|
|
const VkCommandBufferInheritanceInfo cmdbuff_ii = {
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
|
|
nullptr, // pNext
|
|
m_renderPass,
|
|
0, // subpass
|
|
m_framebuffer,
|
|
};
|
|
const VkCommandBufferBeginInfo cmdbuff_bi_tmpl = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
|
nullptr, // pNext
|
|
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii};
|
|
|
|
VkCommandBufferBeginInfo cmdbuff_inside_rp_bi = cmdbuff_bi_tmpl;
|
|
cmdbuff_inside_rp_bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
|
|
sec_cmdbuff_inside_rp.begin(&cmdbuff_inside_rp_bi);
|
|
sec_cmdbuff_inside_rp.end();
|
|
|
|
VkCommandBufferBeginInfo cmdbuff_outside_rp_bi = cmdbuff_bi_tmpl;
|
|
cmdbuff_outside_rp_bi.flags &= ~VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
|
|
sec_cmdbuff_outside_rp.begin(&cmdbuff_outside_rp_bi);
|
|
sec_cmdbuff_outside_rp.end();
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdExecuteCommands-pCommandBuffers-00100");
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_inside_rp.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
|
|
nullptr, // pNext
|
|
m_renderPass,
|
|
m_framebuffer,
|
|
{{0, 0}, {32, 32}},
|
|
static_cast<uint32_t>(m_renderPassClearValues.size()),
|
|
m_renderPassClearValues.data()};
|
|
vkCmdBeginRenderPass(m_commandBuffer->handle(), &rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdExecuteCommands-pCommandBuffers-00096");
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_outside_rp.handle());
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SecondaryCommandBufferClearColorAttachmentsRenderArea) {
|
|
TEST_DESCRIPTION(
|
|
"Create a secondary command buffer with CmdClearAttachments call that has a rect outside of renderPass renderArea");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
VkCommandBufferAllocateInfo command_buffer_allocate_info = {};
|
|
command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
command_buffer_allocate_info.commandPool = m_commandPool->handle();
|
|
command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
|
|
command_buffer_allocate_info.commandBufferCount = 1;
|
|
|
|
VkCommandBuffer secondary_command_buffer;
|
|
ASSERT_VK_SUCCESS(vkAllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer));
|
|
VkCommandBufferBeginInfo command_buffer_begin_info = {};
|
|
VkCommandBufferInheritanceInfo command_buffer_inheritance_info = {};
|
|
command_buffer_inheritance_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
|
|
command_buffer_inheritance_info.renderPass = m_renderPass;
|
|
command_buffer_inheritance_info.framebuffer = m_framebuffer;
|
|
|
|
command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
command_buffer_begin_info.flags =
|
|
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
|
|
command_buffer_begin_info.pInheritanceInfo = &command_buffer_inheritance_info;
|
|
|
|
vkBeginCommandBuffer(secondary_command_buffer, &command_buffer_begin_info);
|
|
VkClearAttachment color_attachment;
|
|
color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
color_attachment.clearValue.color.float32[0] = 0;
|
|
color_attachment.clearValue.color.float32[1] = 0;
|
|
color_attachment.clearValue.color.float32[2] = 0;
|
|
color_attachment.clearValue.color.float32[3] = 0;
|
|
color_attachment.colorAttachment = 0;
|
|
// x extent of 257 exceeds render area of 256
|
|
VkClearRect clear_rect = {{{0, 0}, {257, 32}}, 0, 1};
|
|
vkCmdClearAttachments(secondary_command_buffer, 1, &color_attachment, 1, &clear_rect);
|
|
vkEndCommandBuffer(secondary_command_buffer);
|
|
m_commandBuffer->begin();
|
|
vkCmdBeginRenderPass(m_commandBuffer->handle(), &m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdClearAttachments-pRects-00016");
|
|
vkCmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary_command_buffer);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkCmdEndRenderPass(m_commandBuffer->handle());
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, PushDescriptorSetCmdPushBadArgs) {
|
|
TEST_DESCRIPTION("Attempt to push a push descriptor set with incorrect arguments.");
|
|
if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix,
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
return;
|
|
}
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) {
|
|
m_device_extension_names.push_back(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
|
|
auto push_descriptor_prop = GetPushDescriptorProperties(instance(), gpu());
|
|
if (push_descriptor_prop.maxPushDescriptors < 1) {
|
|
// Some implementations report an invalid maxPushDescriptors of 0
|
|
printf("%s maxPushDescriptors is zero, skipping tests\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
// Create ordinary and push descriptor set layout
|
|
VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr};
|
|
const VkDescriptorSetLayoutObj ds_layout(m_device, {binding});
|
|
ASSERT_TRUE(ds_layout.initialized());
|
|
const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
|
|
ASSERT_TRUE(push_ds_layout.initialized());
|
|
|
|
// Now use the descriptor set layouts to create a pipeline layout
|
|
const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout, &ds_layout});
|
|
ASSERT_TRUE(pipeline_layout.initialized());
|
|
|
|
// Create a descriptor to push
|
|
const uint32_t buffer_data[4] = {4, 5, 6, 7};
|
|
VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data);
|
|
ASSERT_TRUE(buffer_obj.initialized());
|
|
|
|
// Create a "write" struct, noting that the buffer_info cannot be a temporary arg (the return from write_descriptor_set
|
|
// references its data), and the DescriptorSet() can be temporary, because the value is ignored
|
|
VkDescriptorBufferInfo buffer_info = {buffer_obj.handle(), 0, VK_WHOLE_SIZE};
|
|
|
|
VkWriteDescriptorSet descriptor_write = vk_testing::Device::write_descriptor_set(
|
|
vk_testing::DescriptorSet(), 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &buffer_info);
|
|
|
|
// Find address of extension call and make the call
|
|
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR =
|
|
(PFN_vkCmdPushDescriptorSetKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
|
|
ASSERT_TRUE(vkCmdPushDescriptorSetKHR != nullptr);
|
|
|
|
// Section 1: Queue family matching/capabilities.
|
|
// Create command pool on a non-graphics queue
|
|
const uint32_t no_gfx_qfi = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT);
|
|
const uint32_t transfer_only_qfi =
|
|
m_device->QueueFamilyMatching(VK_QUEUE_TRANSFER_BIT, (VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT));
|
|
if ((UINT32_MAX == transfer_only_qfi) && (UINT32_MAX == no_gfx_qfi)) {
|
|
printf("%s No compute or transfer only queue family, skipping bindpoint and queue tests.\n", kSkipPrefix);
|
|
} else {
|
|
const uint32_t err_qfi = (UINT32_MAX == no_gfx_qfi) ? transfer_only_qfi : no_gfx_qfi;
|
|
|
|
VkCommandPoolObj command_pool(m_device, err_qfi);
|
|
ASSERT_TRUE(command_pool.initialized());
|
|
VkCommandBufferObj command_buffer(m_device, &command_pool);
|
|
ASSERT_TRUE(command_buffer.initialized());
|
|
command_buffer.begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkWriteDescriptorSet-descriptorType-00330");
|
|
if (err_qfi == transfer_only_qfi) {
|
|
// This as this queue neither supports the gfx or compute bindpoints, we'll get two errors
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool");
|
|
}
|
|
vkCmdPushDescriptorSetKHR(command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
|
|
&descriptor_write);
|
|
m_errorMonitor->VerifyFound();
|
|
command_buffer.end();
|
|
|
|
// If we succeed in testing only one condition above, we need to test the other below.
|
|
if ((UINT32_MAX != transfer_only_qfi) && (err_qfi != transfer_only_qfi)) {
|
|
// Need to test the neither compute/gfx supported case separately.
|
|
VkCommandPoolObj tran_command_pool(m_device, transfer_only_qfi);
|
|
ASSERT_TRUE(tran_command_pool.initialized());
|
|
VkCommandBufferObj tran_command_buffer(m_device, &tran_command_pool);
|
|
ASSERT_TRUE(tran_command_buffer.initialized());
|
|
tran_command_buffer.begin();
|
|
|
|
// We can't avoid getting *both* errors in this case
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkWriteDescriptorSet-descriptorType-00330");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool");
|
|
vkCmdPushDescriptorSetKHR(tran_command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
|
|
&descriptor_write);
|
|
m_errorMonitor->VerifyFound();
|
|
tran_command_buffer.end();
|
|
}
|
|
}
|
|
|
|
// Push to the non-push binding
|
|
m_commandBuffer->begin();
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushDescriptorSetKHR-set-00365");
|
|
vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 1, 1,
|
|
&descriptor_write);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// Specify set out of bounds
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPushDescriptorSetKHR-set-00364");
|
|
vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 2, 1,
|
|
&descriptor_write);
|
|
m_errorMonitor->VerifyFound();
|
|
m_commandBuffer->end();
|
|
|
|
// This is a test for VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording
|
|
// TODO: Add VALIDATION_ERROR_ code support to core_validation::ValidateCmd
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"You must call vkBeginCommandBuffer() before this call to vkCmdPushDescriptorSetKHR()");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkWriteDescriptorSet-descriptorType-00330");
|
|
vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
|
|
&descriptor_write);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SetDynScissorParamTests) {
|
|
TEST_DESCRIPTION("Test parameters of vkCmdSetScissor without multiViewport feature");
|
|
|
|
VkPhysicalDeviceFeatures features{};
|
|
ASSERT_NO_FATAL_FAILURE(Init(&features));
|
|
|
|
const VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
const VkRect2D scissors[] = {scissor, scissor};
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
// array tests
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00593");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 1, 1, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-arraylength");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-00594");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 2, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00593");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-00594");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 1, 2, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-pScissors-parameter");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
struct TestCase {
|
|
VkRect2D scissor;
|
|
std::string vuid;
|
|
};
|
|
|
|
std::vector<TestCase> test_cases = {{{{-1, 0}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"},
|
|
{{{0, -1}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"},
|
|
{{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
|
|
{{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
|
|
{{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetScissor-offset-00596"},
|
|
{{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetScissor-offset-00597"},
|
|
{{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetScissor-offset-00597"},
|
|
{{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetScissor-offset-00597"}};
|
|
|
|
for (const auto &test_case : test_cases) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, test_case.vuid);
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, SetDynScissorParamMultiviewportTests) {
|
|
TEST_DESCRIPTION("Test parameters of vkCmdSetScissor with multiViewport feature enabled");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
|
|
if (!m_device->phy().features().multiViewport) {
|
|
printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
const auto max_scissors = m_device->props.limits.maxViewports;
|
|
const uint32_t too_many_scissors = 65536 + 1; // let's say this is too much to allocate pScissors for
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-arraylength");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-pScissors-parameter");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, max_scissors, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
if (max_scissors >= too_many_scissors) {
|
|
printf(
|
|
"%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping "
|
|
"part of "
|
|
"test.\n",
|
|
kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
const VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
const std::vector<VkRect2D> scissors(max_scissors + 1, scissor);
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00592");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, max_scissors + 1, scissors.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00592");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), max_scissors, 1, scissors.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00592");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 1, max_scissors, scissors.data());
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-arraylength");
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors.data());
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawIndirect) {
|
|
TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirect");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
CreatePipelineHelper pipe(*this);
|
|
pipe.InitInfo();
|
|
const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
|
|
VkPipelineDynamicStateCreateInfo dyn_state_ci = {};
|
|
dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
dyn_state_ci.dynamicStateCount = size(dyn_states);
|
|
dyn_state_ci.pDynamicStates = dyn_states;
|
|
pipe.dyn_state_ci_ = dyn_state_ci;
|
|
pipe.InitState();
|
|
pipe.CreateGraphicsPipeline();
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
|
|
vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
|
|
&pipe.descriptor_set_->set_, 0, NULL);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
buffer_create_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
|
buffer_create_info.size = sizeof(VkDrawIndirectCommand);
|
|
VkBufferObj draw_buffer;
|
|
draw_buffer.init(*m_device, buffer_create_info);
|
|
|
|
// VUID-vkCmdDrawIndirect-buffer-02709
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirect-buffer-02709");
|
|
vkCmdDrawIndirect(m_commandBuffer->handle(), draw_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawIndirectCountKHR) {
|
|
TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectCountKHR");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)) {
|
|
m_device_extension_names.push_back(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
|
|
} else {
|
|
printf(" VK_KHR_draw_indirect_count Extension not supported, skipping test\n");
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
VkMemoryRequirements memory_requirements;
|
|
VkMemoryAllocateInfo memory_allocate_info = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
|
|
auto vkCmdDrawIndirectCountKHR =
|
|
(PFN_vkCmdDrawIndirectCountKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdDrawIndirectCountKHR");
|
|
|
|
CreatePipelineHelper pipe(*this);
|
|
pipe.InitInfo();
|
|
const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
|
|
VkPipelineDynamicStateCreateInfo dyn_state_ci = {};
|
|
dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
dyn_state_ci.dynamicStateCount = size(dyn_states);
|
|
dyn_state_ci.pDynamicStates = dyn_states;
|
|
pipe.dyn_state_ci_ = dyn_state_ci;
|
|
pipe.InitState();
|
|
pipe.CreateGraphicsPipeline();
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
|
|
vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
|
|
&pipe.descriptor_set_->set_, 0, NULL);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
buffer_create_info.size = sizeof(VkDrawIndirectCommand);
|
|
buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
|
VkBuffer draw_buffer;
|
|
vkCreateBuffer(m_device->device(), &buffer_create_info, nullptr, &draw_buffer);
|
|
|
|
VkBufferCreateInfo count_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
count_buffer_create_info.size = sizeof(uint32_t);
|
|
count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
|
VkBufferObj count_buffer;
|
|
count_buffer.init(*m_device, count_buffer_create_info);
|
|
|
|
// VUID-vkCmdDrawIndirectCountKHR-buffer-02708
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirectCountKHR-buffer-02708");
|
|
vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1,
|
|
sizeof(VkDrawIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkGetBufferMemoryRequirements(m_device->device(), draw_buffer, &memory_requirements);
|
|
memory_allocate_info.allocationSize = memory_requirements.size;
|
|
m_device->phy().set_memory_type(memory_requirements.memoryTypeBits, &memory_allocate_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
|
|
VkDeviceMemory draw_buffer_memory;
|
|
vkAllocateMemory(m_device->device(), &memory_allocate_info, NULL, &draw_buffer_memory);
|
|
vkBindBufferMemory(m_device->device(), draw_buffer, draw_buffer_memory, 0);
|
|
|
|
VkBuffer count_buffer_unbound;
|
|
vkCreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound);
|
|
|
|
// VUID-vkCmdDrawIndirectCountKHR-countBuffer-02714
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirectCountKHR-countBuffer-02714");
|
|
vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer_unbound, 0, 1, sizeof(VkDrawIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndirectCountKHR-offset-02710
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirectCountKHR-offset-02710");
|
|
vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 1, count_buffer.handle(), 0, 1,
|
|
sizeof(VkDrawIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndirectCountKHR-countBufferOffset-02716
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirectCountKHR-countBufferOffset-02716");
|
|
vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 1, 1,
|
|
sizeof(VkDrawIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndirectCountKHR-stride-03110
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndirectCountKHR-stride-03110");
|
|
vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1, 1);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vkCmdDraw* equivalent of
|
|
// these:
|
|
// VUID-vkCmdDrawIndirectCountKHR-renderPass-02684
|
|
// VUID-vkCmdDrawIndirectCountKHR-subpass-02685
|
|
// VUID-vkCmdDrawIndirectCountKHR-commandBuffer-02701
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
|
|
vkDestroyBuffer(m_device->device(), draw_buffer, 0);
|
|
vkDestroyBuffer(m_device->device(), count_buffer_unbound, 0);
|
|
|
|
vkFreeMemory(m_device->device(), draw_buffer_memory, 0);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, DrawIndexedIndirectCountKHR) {
|
|
TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndexedIndirectCountKHR");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)) {
|
|
m_device_extension_names.push_back(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
|
|
} else {
|
|
printf(" VK_KHR_draw_indirect_count Extension not supported, skipping test\n");
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitState());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
auto vkCmdDrawIndexedIndirectCountKHR =
|
|
(PFN_vkCmdDrawIndexedIndirectCountKHR)vkGetDeviceProcAddr(m_device->device(), "vkCmdDrawIndexedIndirectCountKHR");
|
|
|
|
CreatePipelineHelper pipe(*this);
|
|
pipe.InitInfo();
|
|
const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
|
|
VkPipelineDynamicStateCreateInfo dyn_state_ci = {};
|
|
dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
dyn_state_ci.dynamicStateCount = size(dyn_states);
|
|
dyn_state_ci.pDynamicStates = dyn_states;
|
|
pipe.dyn_state_ci_ = dyn_state_ci;
|
|
pipe.InitState();
|
|
pipe.CreateGraphicsPipeline();
|
|
|
|
m_commandBuffer->begin();
|
|
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
|
|
|
|
vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
|
|
vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
|
|
&pipe.descriptor_set_->set_, 0, NULL);
|
|
|
|
VkViewport viewport = {0, 0, 16, 16, 0, 1};
|
|
vkCmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
|
|
VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
vkCmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
|
|
|
|
VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
buffer_create_info.size = sizeof(VkDrawIndexedIndirectCommand);
|
|
buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
|
VkBufferObj draw_buffer;
|
|
draw_buffer.init(*m_device, buffer_create_info);
|
|
|
|
VkBufferCreateInfo count_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
count_buffer_create_info.size = sizeof(uint32_t);
|
|
count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
|
VkBufferObj count_buffer;
|
|
count_buffer.init(*m_device, count_buffer_create_info);
|
|
|
|
VkBufferCreateInfo index_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
index_buffer_create_info.size = sizeof(uint32_t);
|
|
index_buffer_create_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
|
|
VkBufferObj index_buffer;
|
|
index_buffer.init(*m_device, index_buffer_create_info);
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-02701 (partial - only tests whether the index buffer is bound)
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-02701");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1,
|
|
sizeof(VkDrawIndexedIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkCmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
|
|
|
|
VkBuffer draw_buffer_unbound;
|
|
vkCreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &draw_buffer_unbound);
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-02708
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-02708");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer_unbound, 0, count_buffer.handle(), 0, 1,
|
|
sizeof(VkDrawIndexedIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
VkBuffer count_buffer_unbound;
|
|
vkCreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound);
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-02714
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-02714");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_unbound, 0, 1,
|
|
sizeof(VkDrawIndexedIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-offset-02710
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndexedIndirectCountKHR-offset-02710");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 1, count_buffer.handle(), 0, 1,
|
|
sizeof(VkDrawIndexedIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-countBufferOffset-02716
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdDrawIndexedIndirectCountKHR-countBufferOffset-02716");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 1, 1,
|
|
sizeof(VkDrawIndexedIndirectCommand));
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-stride-03142
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawIndexedIndirectCountKHR-stride-03142");
|
|
vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, 1);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
// TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vkCmdDraw* equivalent of
|
|
// these:
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-renderPass-02684
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-subpass-02685
|
|
// VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-02701 (partial)
|
|
|
|
m_commandBuffer->EndRenderPass();
|
|
m_commandBuffer->end();
|
|
|
|
vkDestroyBuffer(m_device->device(), draw_buffer_unbound, 0);
|
|
vkDestroyBuffer(m_device->device(), count_buffer_unbound, 0);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, ExclusiveScissorNV) {
|
|
TEST_DESCRIPTION("Test VK_NV_scissor_exclusive with multiViewport disabled.");
|
|
|
|
if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
std::array<const char *, 1> required_device_extensions = {{VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME}};
|
|
for (auto device_extension : required_device_extensions) {
|
|
if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
|
|
m_device_extension_names.push_back(device_extension);
|
|
} else {
|
|
printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
|
|
return;
|
|
}
|
|
}
|
|
|
|
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
|
|
(PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
|
|
ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
|
|
|
|
// Create a device that enables exclusive scissor but disables multiViewport
|
|
auto exclusive_scissor_features = lvl_init_struct<VkPhysicalDeviceExclusiveScissorFeaturesNV>();
|
|
auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&exclusive_scissor_features);
|
|
vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
|
|
|
|
features2.features.multiViewport = VK_FALSE;
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
if (m_device->phy().properties().limits.maxViewports) {
|
|
printf("%s Device doesn't support the necessary number of viewports, skipping test.\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
// Based on PSOViewportStateTests
|
|
{
|
|
VkViewport viewport = {0.0f, 0.0f, 64.0f, 64.0f, 0.0f, 1.0f};
|
|
VkViewport viewports[] = {viewport, viewport};
|
|
VkRect2D scissor = {{0, 0}, {64, 64}};
|
|
VkRect2D scissors[100] = {scissor, scissor};
|
|
|
|
using std::vector;
|
|
struct TestCase {
|
|
uint32_t viewport_count;
|
|
VkViewport *viewports;
|
|
uint32_t scissor_count;
|
|
VkRect2D *scissors;
|
|
uint32_t exclusive_scissor_count;
|
|
VkRect2D *exclusive_scissors;
|
|
|
|
vector<std::string> vuids;
|
|
};
|
|
|
|
vector<TestCase> test_cases = {
|
|
{1,
|
|
viewports,
|
|
1,
|
|
scissors,
|
|
2,
|
|
scissors,
|
|
{"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
|
|
"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}},
|
|
{1,
|
|
viewports,
|
|
1,
|
|
scissors,
|
|
100,
|
|
scissors,
|
|
{"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
|
|
"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028",
|
|
"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}},
|
|
{1,
|
|
viewports,
|
|
1,
|
|
scissors,
|
|
1,
|
|
nullptr,
|
|
{"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030"}},
|
|
};
|
|
|
|
for (const auto &test_case : test_cases) {
|
|
VkPipelineViewportExclusiveScissorStateCreateInfoNV exc = {
|
|
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV};
|
|
|
|
const auto break_vp = [&test_case, &exc](CreatePipelineHelper &helper) {
|
|
helper.vp_state_ci_.viewportCount = test_case.viewport_count;
|
|
helper.vp_state_ci_.pViewports = test_case.viewports;
|
|
helper.vp_state_ci_.scissorCount = test_case.scissor_count;
|
|
helper.vp_state_ci_.pScissors = test_case.scissors;
|
|
helper.vp_state_ci_.pNext = &exc;
|
|
|
|
exc.exclusiveScissorCount = test_case.exclusive_scissor_count;
|
|
exc.pExclusiveScissors = test_case.exclusive_scissors;
|
|
};
|
|
CreatePipelineHelper::OneshotTest(*this, break_vp, VK_DEBUG_REPORT_ERROR_BIT_EXT, test_case.vuids);
|
|
}
|
|
}
|
|
|
|
// Based on SetDynScissorParamTests
|
|
{
|
|
auto vkCmdSetExclusiveScissorNV =
|
|
(PFN_vkCmdSetExclusiveScissorNV)vkGetDeviceProcAddr(m_device->device(), "vkCmdSetExclusiveScissorNV");
|
|
|
|
const VkRect2D scissor = {{0, 0}, {16, 16}};
|
|
const VkRect2D scissors[] = {scissor, scissor};
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 1, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 2, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 0, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 2, scissors);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
"vkCmdSetExclusiveScissorNV: required parameter pExclusiveScissors specified as NULL");
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
struct TestCase {
|
|
VkRect2D scissor;
|
|
std::string vuid;
|
|
};
|
|
|
|
std::vector<TestCase> test_cases = {
|
|
{{{-1, 0}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"},
|
|
{{{0, -1}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"},
|
|
{{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
|
|
{{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
|
|
{{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"},
|
|
{{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"},
|
|
{{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"},
|
|
{{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"}};
|
|
|
|
for (const auto &test_case : test_cases) {
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, test_case.vuid);
|
|
vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
|
|
m_errorMonitor->VerifyFound();
|
|
}
|
|
|
|
m_commandBuffer->end();
|
|
}
|
|
}
|
|
|
|
TEST_F(VkLayerTest, MeshShaderNV) {
|
|
TEST_DESCRIPTION("Test VK_NV_mesh_shader.");
|
|
|
|
if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
|
m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
} else {
|
|
printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
return;
|
|
}
|
|
ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
|
|
std::array<const char *, 1> required_device_extensions = {{VK_NV_MESH_SHADER_EXTENSION_NAME}};
|
|
for (auto device_extension : required_device_extensions) {
|
|
if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
|
|
m_device_extension_names.push_back(device_extension);
|
|
} else {
|
|
printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (DeviceIsMockICD() || DeviceSimulation()) {
|
|
printf("%sNot suppored by MockICD, skipping tests\n", kSkipPrefix);
|
|
return;
|
|
}
|
|
|
|
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
|
|
(PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
|
|
ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
|
|
|
|
// Create a device that enables mesh_shader
|
|
auto mesh_shader_features = lvl_init_struct<VkPhysicalDeviceMeshShaderFeaturesNV>();
|
|
auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&mesh_shader_features);
|
|
vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
|
|
features2.features.multiDrawIndirect = VK_FALSE;
|
|
|
|
ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
static const char vertShaderText[] =
|
|
"#version 450\n"
|
|
"vec2 vertices[3];\n"
|
|
"void main() {\n"
|
|
" vertices[0] = vec2(-1.0, -1.0);\n"
|
|
" vertices[1] = vec2( 1.0, -1.0);\n"
|
|
" vertices[2] = vec2( 0.0, 1.0);\n"
|
|
" gl_Position = vec4(vertices[gl_VertexIndex % 3], 0.0, 1.0);\n"
|
|
" gl_PointSize = 1.0f;\n"
|
|
"}\n";
|
|
|
|
static const char meshShaderText[] =
|
|
"#version 450\n"
|
|
"#extension GL_NV_mesh_shader : require\n"
|
|
"layout(local_size_x = 1) in;\n"
|
|
"layout(max_vertices = 3) out;\n"
|
|
"layout(max_primitives = 1) out;\n"
|
|
"layout(triangles) out;\n"
|
|
"void main() {\n"
|
|
" gl_MeshVerticesNV[0].gl_Position = vec4(-1.0, -1.0, 0, 1);\n"
|
|
" gl_MeshVerticesNV[1].gl_Position = vec4( 1.0, -1.0, 0, 1);\n"
|
|
" gl_MeshVerticesNV[2].gl_Position = vec4( 0.0, 1.0, 0, 1);\n"
|
|
" gl_PrimitiveIndicesNV[0] = 0;\n"
|
|
" gl_PrimitiveIndicesNV[1] = 1;\n"
|
|
" gl_PrimitiveIndicesNV[2] = 2;\n"
|
|
" gl_PrimitiveCountNV = 1;\n"
|
|
"}\n";
|
|
|
|
VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkShaderObj ms(m_device, meshShaderText, VK_SHADER_STAGE_MESH_BIT_NV, this);
|
|
VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
|
|
|
|
// Test pipeline creation
|
|
{
|
|
// can't mix mesh with vertex
|
|
const auto break_vp = [&](CreatePipelineHelper &helper) {
|
|
helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo(), ms.GetStageCreateInfo()};
|
|
};
|
|
CreatePipelineHelper::OneshotTest(*this, break_vp, VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02095"}));
|
|
|
|
// vertex or mesh must be present
|
|
const auto break_vp2 = [&](CreatePipelineHelper &helper) { helper.shader_stages_ = {fs.GetStageCreateInfo()}; };
|
|
CreatePipelineHelper::OneshotTest(*this, break_vp2, VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-stage-02096"}));
|
|
|
|
// vertexinput and inputassembly must be valid when vertex stage is present
|
|
const auto break_vp3 = [&](CreatePipelineHelper &helper) {
|
|
helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()};
|
|
helper.gp_ci_.pVertexInputState = nullptr;
|
|
helper.gp_ci_.pInputAssemblyState = nullptr;
|
|
};
|
|
CreatePipelineHelper::OneshotTest(*this, break_vp3, VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02097",
|
|
"VUID-VkGraphicsPipelineCreateInfo-pStages-02098"}));
|
|
}
|
|
|
|
PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV =
|
|
(PFN_vkCmdDrawMeshTasksIndirectNV)vkGetInstanceProcAddr(instance(), "vkCmdDrawMeshTasksIndirectNV");
|
|
|
|
VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
buffer_create_info.size = sizeof(uint32_t);
|
|
buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
|
VkBuffer buffer;
|
|
VkResult result = vkCreateBuffer(m_device->device(), &buffer_create_info, nullptr, &buffer);
|
|
ASSERT_VK_SUCCESS(result);
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718");
|
|
vkCmdDrawMeshTasksIndirectNV(m_commandBuffer->handle(), buffer, 0, 2, 0);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
|
|
vkDestroyBuffer(m_device->device(), buffer, 0);
|
|
}
|
|
|
|
TEST_F(VkLayerTest, MeshShaderDisabledNV) {
|
|
TEST_DESCRIPTION("Test VK_NV_mesh_shader VUs with NV_mesh_shader disabled.");
|
|
ASSERT_NO_FATAL_FAILURE(Init());
|
|
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
|
|
|
|
VkEvent event;
|
|
VkEventCreateInfo event_create_info{};
|
|
event_create_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
|
|
vkCreateEvent(m_device->device(), &event_create_info, nullptr, &event);
|
|
|
|
m_commandBuffer->begin();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetEvent-stageMask-02107");
|
|
vkCmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetEvent-stageMask-02108");
|
|
vkCmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResetEvent-stageMask-02109");
|
|
vkCmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdResetEvent-stageMask-02110");
|
|
vkCmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdWaitEvents-srcStageMask-02111");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdWaitEvents-dstStageMask-02113");
|
|
vkCmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
|
|
VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdWaitEvents-srcStageMask-02112");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdWaitEvents-dstStageMask-02114");
|
|
vkCmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
|
|
VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPipelineBarrier-srcStageMask-02115");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPipelineBarrier-dstStageMask-02117");
|
|
vkCmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0,
|
|
0, nullptr, 0, nullptr, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPipelineBarrier-srcStageMask-02116");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdPipelineBarrier-dstStageMask-02118");
|
|
vkCmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0,
|
|
0, nullptr, 0, nullptr, 0, nullptr);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
m_commandBuffer->end();
|
|
|
|
VkSemaphoreCreateInfo semaphore_create_info = {};
|
|
semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
VkSemaphore semaphore;
|
|
ASSERT_VK_SUCCESS(vkCreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore));
|
|
|
|
VkPipelineStageFlags stage_flags = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV | VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV;
|
|
VkSubmitInfo submit_info = {};
|
|
|
|
// Signal the semaphore so the next test can wait on it.
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.signalSemaphoreCount = 1;
|
|
submit_info.pSignalSemaphores = &semaphore;
|
|
vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
m_errorMonitor->VerifyNotFound();
|
|
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.signalSemaphoreCount = 0;
|
|
submit_info.pSignalSemaphores = nullptr;
|
|
submit_info.waitSemaphoreCount = 1;
|
|
submit_info.pWaitSemaphores = &semaphore;
|
|
submit_info.pWaitDstStageMask = &stage_flags;
|
|
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkSubmitInfo-pWaitDstStageMask-02089");
|
|
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkSubmitInfo-pWaitDstStageMask-02090");
|
|
vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
|
|
m_errorMonitor->VerifyFound();
|
|
|
|
vkQueueWaitIdle(m_device->m_queue);
|
|
|
|
VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
|
|
VkPipelineShaderStageCreateInfo meshStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO};
|
|
meshStage = vs.GetStageCreateInfo();
|
|
meshStage.stage = VK_SHADER_STAGE_MESH_BIT_NV;
|
|
VkPipelineShaderStageCreateInfo taskStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO};
|
|
taskStage = vs.GetStageCreateInfo();
|
|
taskStage.stage = VK_SHADER_STAGE_TASK_BIT_NV;
|
|
|
|
// mesh and task shaders not supported
|
|
const auto break_vp = [&](CreatePipelineHelper &helper) {
|
|
helper.shader_stages_ = {meshStage, taskStage, vs.GetStageCreateInfo()};
|
|
};
|
|
CreatePipelineHelper::OneshotTest(
|
|
*this, break_vp, VK_DEBUG_REPORT_ERROR_BIT_EXT,
|
|
vector<std::string>({"VUID-VkPipelineShaderStageCreateInfo-pName-00707", "VUID-VkPipelineShaderStageCreateInfo-pName-00707",
|
|
"VUID-VkPipelineShaderStageCreateInfo-stage-02091",
|
|
"VUID-VkPipelineShaderStageCreateInfo-stage-02092"}));
|
|
|
|
vkDestroyEvent(m_device->device(), event, nullptr);
|
|
vkDestroySemaphore(m_device->device(), semaphore, nullptr);
|
|
}
|