/* * Copyright (c) 2015-2023 The Khronos Group Inc. * Copyright (c) 2015-2023 Valve Corporation * Copyright (c) 2015-2023 LunarG, Inc. * Copyright (c) 2015-2023 Google, Inc. * Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. * * 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 */ #include "cast_utils.h" #include "enum_flag_bits.h" #include "../framework/layer_validation_tests.h" #include "vk_layer_utils.h" TEST_F(VkLayerTest, InvalidUsageBits) { TEST_DESCRIPTION( "Specify wrong usage for image then create conflicting view of image Initialize buffer with wrong usage then perform copy " "expecting errors from both the image and the buffer (2 calls)"); AddOptionalExtensions(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool copy_commands2 = IsExtensionsEnabled(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2Function = nullptr; if (copy_commands2) { vkCmdCopyBufferToImage2Function = (PFN_vkCmdCopyBufferToImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdCopyBufferToImage2KHR"); } auto format = FindSupportedDepthStencilFormat(gpu()); VkImageObj image(m_device); // Initialize image with transfer source usage image.Init(128, 128, 1, format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkImageView dsv; VkImageViewCreateInfo dsvci = LvlInitStruct(); dsvci.image = image.handle(); dsvci.viewType = VK_IMAGE_VIEW_TYPE_2D; dsvci.format = format; dsvci.subresourceRange.layerCount = 1; dsvci.subresourceRange.baseMipLevel = 0; dsvci.subresourceRange.levelCount = 1; dsvci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; // Create a view with depth / stencil aspect for image with different usage m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-04441"); vk::CreateImageView(m_device->device(), &dsvci, NULL, &dsv); m_errorMonitor->VerifyFound(); // Initialize buffer with TRANSFER_DST usage VkBufferObj buffer; VkMemoryPropertyFlags reqs = 0; buffer.init_as_dst(*m_device, 128 * 128, reqs); VkBufferImageCopy region = {}; region.bufferRowLength = 128; region.bufferImageHeight = 128; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; region.imageSubresource.layerCount = 1; region.imageExtent.height = 16; region.imageExtent.width = 16; region.imageExtent.depth = 1; // Buffer usage not set to TRANSFER_SRC and image usage not set to TRANSFER_DST m_commandBuffer->begin(); // two separate errors from this call: m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-dstImage-00177"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-srcBuffer-00174"); vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); m_errorMonitor->VerifyFound(); // equvalent test using using KHR_copy_commands2 if (copy_commands2 && vkCmdCopyBufferToImage2Function) { const VkBufferImageCopy2KHR region2 = {VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, NULL, region.bufferRowLength, region.bufferImageHeight, region.bufferImageHeight, region.imageSubresource, region.imageOffset, region.imageExtent}; VkCopyBufferToImageInfo2KHR buffer_to_image_info2 = {VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, NULL, buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion2}; // two separate errors from this call: m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyBufferToImageInfo2-dstImage-00177"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyBufferToImageInfo2-srcBuffer-00174"); vkCmdCopyBufferToImage2Function(m_commandBuffer->handle(), &buffer_to_image_info2); m_errorMonitor->VerifyFound(); } } TEST_F(VkLayerTest, CopyBufferToCompressedImage) { TEST_DESCRIPTION("Copy buffer to compressed image when buffer is larger than image."); ASSERT_NO_FATAL_FAILURE(Init()); // Verify format support if (!ImageFormatAndFeaturesSupported(gpu(), VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR)) { GTEST_SKIP() << "Required formats/features not supported"; } VkImageObj width_image(m_device); VkImageObj height_image(m_device); VkBufferObj buffer; VkMemoryPropertyFlags reqs = 0; buffer.init_as_src(*m_device, 8 * 4 * 2, reqs); VkBufferImageCopy region = {}; region.bufferRowLength = 0; region.bufferImageHeight = 0; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; region.imageSubresource.layerCount = 1; region.imageExtent.width = 8; region.imageExtent.height = 4; region.imageExtent.depth = 1; width_image.Init(5, 4, 1, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL); height_image.Init(8, 3, 1, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL); if (!width_image.initialized() || (!height_image.initialized())) { GTEST_SKIP() << "Unable to initialize surfaces"; } m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-07928"); vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), width_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageOffset-00200"); m_errorMonitor->SetUnexpectedError("VUID-vkCmdCopyBufferToImage-pRegions-07927"); VkResult err; VkImageCreateInfo depth_image_create_info = LvlInitStruct(); depth_image_create_info.imageType = VK_IMAGE_TYPE_3D; depth_image_create_info.format = VK_FORMAT_BC1_RGBA_SRGB_BLOCK; depth_image_create_info.extent.width = 8; depth_image_create_info.extent.height = 4; depth_image_create_info.extent.depth = 1; depth_image_create_info.mipLevels = 1; depth_image_create_info.arrayLayers = 1; depth_image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; depth_image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; depth_image_create_info.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED; depth_image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; depth_image_create_info.queueFamilyIndexCount = 0; depth_image_create_info.pQueueFamilyIndices = NULL; VkImage depth_image = VK_NULL_HANDLE; err = vk::CreateImage(m_device->handle(), &depth_image_create_info, NULL, &depth_image); ASSERT_VK_SUCCESS(err); VkDeviceMemory mem1; VkMemoryRequirements mem_reqs; mem_reqs.memoryTypeBits = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; VkMemoryAllocateInfo mem_alloc = LvlInitStruct(); mem_alloc.allocationSize = 0; mem_alloc.memoryTypeIndex = 0; mem_alloc.memoryTypeIndex = 1; vk::GetImageMemoryRequirements(m_device->device(), depth_image, &mem_reqs); mem_alloc.allocationSize = mem_reqs.size; bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0); ASSERT_TRUE(pass); err = vk::AllocateMemory(m_device->device(), &mem_alloc, NULL, &mem1); ASSERT_VK_SUCCESS(err); err = vk::BindImageMemory(m_device->device(), depth_image, mem1, 0); region.imageExtent.depth = 2; vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), depth_image, VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); vk::DestroyImage(m_device->device(), depth_image, NULL); vk::FreeMemory(m_device->device(), mem1, NULL); m_commandBuffer->end(); } TEST_F(VkLayerTest, CreateUnknownObject) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageMemoryRequirements-image-parameter"); TEST_DESCRIPTION("Pass an invalid image object handle into a Vulkan API call."); ASSERT_NO_FATAL_FAILURE(Init()); // Pass bogus handle into GetImageMemoryRequirements VkMemoryRequirements mem_reqs; constexpr uint64_t fakeImageHandle = 0xCADECADE; VkImage fauxImage = CastFromUint64(fakeImageHandle); vk::GetImageMemoryRequirements(m_device->device(), fauxImage, &mem_reqs); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, ImageSampleCounts) { TEST_DESCRIPTION("Use bad sample counts in image transfer calls to trigger validation errors."); ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); VkMemoryPropertyFlags reqs = 0; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; image_create_info.extent.width = 256; image_create_info.extent.height = 256; image_create_info.extent.depth = 1; image_create_info.mipLevels = 1; image_create_info.arrayLayers = 1; image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_create_info.flags = 0; VkImageBlit blit_region = {}; blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.srcSubresource.baseArrayLayer = 0; blit_region.srcSubresource.layerCount = 1; blit_region.srcSubresource.mipLevel = 0; blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.dstSubresource.baseArrayLayer = 0; blit_region.dstSubresource.layerCount = 1; blit_region.dstSubresource.mipLevel = 0; blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.srcOffsets[1] = {256, 256, 1}; blit_region.dstOffsets[0] = {0, 0, 0}; blit_region.dstOffsets[1] = {128, 128, 1}; // Create two images, the source with sampleCount = 4, and attempt to blit // between them { image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkImageObj src_image(m_device); src_image.init(&image_create_info); src_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj dst_image(m_device); dst_image.init(&image_create_info); dst_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00233"); vk::CmdBlitImage(m_commandBuffer->handle(), src_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } // Create two images, the dest with sampleCount = 4, and attempt to blit // between them { image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkImageObj src_image(m_device); src_image.init(&image_create_info); src_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj dst_image(m_device); dst_image.init(&image_create_info); dst_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-00234"); vk::CmdBlitImage(m_commandBuffer->handle(), src_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } VkBufferImageCopy copy_region = {}; copy_region.bufferRowLength = 128; copy_region.bufferImageHeight = 128; copy_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; copy_region.imageSubresource.layerCount = 1; copy_region.imageExtent.height = 64; copy_region.imageExtent.width = 64; copy_region.imageExtent.depth = 1; // Create src buffer and dst image with sampleCount = 4 and attempt to copy // buffer to image { VkBufferObj src_buffer; src_buffer.init_as_src(*m_device, 128 * 128 * 4, reqs); image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj dst_image(m_device); dst_image.init(&image_create_info); dst_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg( kErrorBit, "was created with a sample count of VK_SAMPLE_COUNT_4_BIT but must be VK_SAMPLE_COUNT_1_BIT"); vk::CmdCopyBufferToImage(m_commandBuffer->handle(), src_buffer.handle(), dst_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_region); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } // Create dst buffer and src image with sampleCount = 4 and attempt to copy // image to buffer { VkBufferObj dst_buffer; dst_buffer.init_as_dst(*m_device, 128 * 128 * 4, reqs); image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; vk_testing::Image src_image; src_image.init(*m_device, (const VkImageCreateInfo &)image_create_info, reqs); m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg( kErrorBit, "was created with a sample count of VK_SAMPLE_COUNT_4_BIT but must be VK_SAMPLE_COUNT_1_BIT"); vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), src_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_buffer.handle(), 1, ©_region); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } } TEST_F(VkLayerTest, BlitImageFormatTypes) { AddOptionalExtensions(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool copy_commands2 = IsExtensionsEnabled(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); PFN_vkCmdBlitImage2KHR vkCmdBlitImage2Function = nullptr; if (copy_commands2) { vkCmdBlitImage2Function = (PFN_vkCmdBlitImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdBlitImage2KHR"); } VkFormat f_unsigned = VK_FORMAT_R8G8B8A8_UINT; VkFormat f_signed = VK_FORMAT_R8G8B8A8_SINT; VkFormat f_float = VK_FORMAT_R32_SFLOAT; VkFormat f_depth = VK_FORMAT_D32_SFLOAT_S8_UINT; VkFormat f_depth2 = VK_FORMAT_D32_SFLOAT; VkFormat f_ycbcr = VK_FORMAT_B16G16R16G16_422_UNORM; if (!ImageFormatIsSupported(gpu(), f_unsigned, VK_IMAGE_TILING_OPTIMAL) || !ImageFormatIsSupported(gpu(), f_signed, VK_IMAGE_TILING_OPTIMAL) || !ImageFormatIsSupported(gpu(), f_float, VK_IMAGE_TILING_OPTIMAL) || !ImageFormatIsSupported(gpu(), f_depth, VK_IMAGE_TILING_OPTIMAL) || !ImageFormatIsSupported(gpu(), f_depth2, VK_IMAGE_TILING_OPTIMAL)) { GTEST_SKIP() << "Requested formats not supported"; } // Note any missing feature bits bool usrc = !ImageFormatAndFeaturesSupported(gpu(), f_unsigned, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT); bool udst = !ImageFormatAndFeaturesSupported(gpu(), f_unsigned, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_DST_BIT); bool ssrc = !ImageFormatAndFeaturesSupported(gpu(), f_signed, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT); bool sdst = !ImageFormatAndFeaturesSupported(gpu(), f_signed, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_DST_BIT); bool fsrc = !ImageFormatAndFeaturesSupported(gpu(), f_float, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT); bool fdst = !ImageFormatAndFeaturesSupported(gpu(), f_float, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_DST_BIT); bool d1dst = !ImageFormatAndFeaturesSupported(gpu(), f_depth, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_DST_BIT); bool d2src = !ImageFormatAndFeaturesSupported(gpu(), f_depth2, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT); VkImageObj unsigned_image(m_device); unsigned_image.Init(64, 64, 1, f_unsigned, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(unsigned_image.initialized()); unsigned_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); VkImageObj signed_image(m_device); signed_image.Init(64, 64, 1, f_signed, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(signed_image.initialized()); signed_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); VkImageObj float_image(m_device); float_image.Init(64, 64, 1, f_float, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(float_image.initialized()); float_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); VkImageObj depth_image(m_device); depth_image.Init(64, 64, 1, f_depth, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(depth_image.initialized()); depth_image.SetLayout(VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_LAYOUT_GENERAL); VkImageObj depth_image2(m_device); depth_image2.Init(64, 64, 1, f_depth2, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(depth_image2.initialized()); depth_image2.SetLayout(VK_IMAGE_ASPECT_DEPTH_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] = {0, 0, 0}; blitRegion.srcOffsets[1] = {64, 64, 1}; blitRegion.dstOffsets[0] = {0, 0, 0}; blitRegion.dstOffsets[1] = {32, 32, 1}; m_commandBuffer->begin(); // Unsigned int vs not an int m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00230"); if (usrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (fdst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), unsigned_image.image(), unsigned_image.Layout(), float_image.image(), float_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // equivalent test using KHR_copy_commands2 if (copy_commands2 && vkCmdBlitImage2Function) { const VkImageBlit2KHR blitRegion2 = { VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, NULL, blitRegion.srcSubresource, {blitRegion.srcOffsets[0], blitRegion.srcOffsets[1]}, blitRegion.dstSubresource, {blitRegion.dstOffsets[0], blitRegion.dstOffsets[1]}}; const VkBlitImageInfo2KHR blit_image_info2 = {VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, NULL, unsigned_image.image(), unsigned_image.Layout(), float_image.image(), float_image.Layout(), 1, &blitRegion2, VK_FILTER_NEAREST}; // Unsigned int vs not an int m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBlitImageInfo2-srcImage-00230"); if (usrc) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-srcImage-01999"); if (fdst) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-dstImage-02000"); vkCmdBlitImage2Function(m_commandBuffer->handle(), &blit_image_info2); m_errorMonitor->VerifyFound(); } m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00230"); if (fsrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (udst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), float_image.image(), float_image.Layout(), unsigned_image.image(), unsigned_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // equivalent test using KHR_copy_commands2 if (copy_commands2 && vkCmdBlitImage2Function) { const VkImageBlit2KHR blitRegion2 = { VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, NULL, blitRegion.srcSubresource, {blitRegion.srcOffsets[0], blitRegion.srcOffsets[1]}, blitRegion.dstSubresource, {blitRegion.dstOffsets[0], blitRegion.dstOffsets[1]}}; const VkBlitImageInfo2KHR blit_image_info2 = {VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, NULL, float_image.image(), float_image.Layout(), unsigned_image.image(), unsigned_image.Layout(), 1, &blitRegion2, VK_FILTER_NEAREST}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBlitImageInfo2-srcImage-00230"); if (fsrc) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-srcImage-01999"); if (udst) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-dstImage-02000"); vkCmdBlitImage2Function(m_commandBuffer->handle(), &blit_image_info2); m_errorMonitor->VerifyFound(); } // Signed int vs not an int, m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00229"); if (ssrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (fdst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), signed_image.image(), signed_image.Layout(), float_image.image(), float_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // equivalent test using KHR_copy_commands2 if (copy_commands2 && vkCmdBlitImage2Function) { const VkImageBlit2KHR blitRegion2 = { VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, NULL, blitRegion.srcSubresource, {blitRegion.srcOffsets[0], blitRegion.srcOffsets[1]}, blitRegion.dstSubresource, {blitRegion.dstOffsets[0], blitRegion.dstOffsets[1]}}; const VkBlitImageInfo2KHR blit_image_info2 = {VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, NULL, signed_image.image(), signed_image.Layout(), float_image.image(), float_image.Layout(), 1, &blitRegion2, VK_FILTER_NEAREST}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBlitImageInfo2-srcImage-00229"); if (ssrc) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-srcImage-01999"); if (fdst) m_errorMonitor->SetUnexpectedError("VUID-VkBlitImageInfo2-dstImage-02000"); vkCmdBlitImage2Function(m_commandBuffer->handle(), &blit_image_info2); m_errorMonitor->VerifyFound(); } m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00229"); if (fsrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (sdst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), float_image.image(), float_image.Layout(), signed_image.image(), signed_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Signed vs Unsigned int - generates both VUs m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00229"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00230"); if (ssrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (udst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), signed_image.image(), signed_image.Layout(), unsigned_image.image(), unsigned_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00229"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00230"); if (usrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (sdst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), unsigned_image.image(), unsigned_image.Layout(), signed_image.image(), signed_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); if (IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) && ImageFormatIsSupported(gpu(), f_ycbcr, VK_IMAGE_TILING_OPTIMAL)) { bool ycbcrsrc = !ImageFormatAndFeaturesSupported(gpu(), f_ycbcr, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT); bool ycbcrdst = !ImageFormatAndFeaturesSupported(gpu(), f_ycbcr, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_DST_BIT); VkImageObj ycbcr_image(m_device); ycbcr_image.Init(64, 64, 1, f_ycbcr, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(ycbcr_image.initialized()); ycbcr_image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); VkImageObj ycbcr_image_2(m_device); ycbcr_image_2.Init(64, 64, 1, f_ycbcr, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(ycbcr_image_2.initialized()); ycbcr_image_2.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); // Src, dst is ycbcr format m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-06421"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-06422"); if (ycbcrsrc) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (ycbcrdst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), ycbcr_image.image(), ycbcr_image.Layout(), ycbcr_image_2.image(), ycbcr_image_2.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); } else { printf("Requested ycbcr format not supported - skipping test case.\n"); } // Depth vs any non-identical depth format m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00231"); blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; if (d2src) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-srcImage-01999"); if (d1dst) m_errorMonitor->SetUnexpectedError("VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), depth_image2.image(), depth_image2.Layout(), depth_image.image(), depth_image.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, BlitImageFilters) { AddOptionalExtensions(VK_IMG_FILTER_CUBIC_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool cubic_support = IsExtensionsEnabled(VK_IMG_FILTER_CUBIC_EXTENSION_NAME); VkFormat fmt = VK_FORMAT_R8_UINT; if (!ImageFormatIsSupported(gpu(), fmt, VK_IMAGE_TILING_OPTIMAL)) { GTEST_SKIP() << "No R8_UINT format support"; } // Create 2D images VkImageObj src2D(m_device); VkImageObj dst2D(m_device); src2D.Init(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0); dst2D.Init(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(src2D.initialized()); ASSERT_TRUE(dst2D.initialized()); src2D.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); dst2D.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); // Create 3D image VkImageCreateInfo ci = LvlInitStruct(); ci.imageType = VK_IMAGE_TYPE_3D; ci.format = fmt; ci.extent = {64, 64, 4}; 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; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj src3D(m_device); src3D.init(&ci); ASSERT_TRUE(src3D.initialized()); 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] = {0, 0, 0}; blitRegion.srcOffsets[1] = {48, 48, 1}; blitRegion.dstOffsets[0] = {0, 0, 0}; blitRegion.dstOffsets[1] = {64, 64, 1}; m_commandBuffer->begin(); // UINT format should not support linear filtering, but check to be sure if (!ImageFormatAndFeaturesSupported(gpu(), fmt, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-filter-02001"); vk::CmdBlitImage(m_commandBuffer->handle(), src2D.image(), src2D.Layout(), dst2D.image(), dst2D.Layout(), 1, &blitRegion, VK_FILTER_LINEAR); m_errorMonitor->VerifyFound(); } if (cubic_support && !ImageFormatAndFeaturesSupported(gpu(), fmt, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG)) { // Invalid filter CUBIC_IMG m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-filter-02002"); vk::CmdBlitImage(m_commandBuffer->handle(), src2D.image(), src2D.Layout(), dst2D.image(), dst2D.Layout(), 1, &blitRegion, VK_FILTER_CUBIC_IMG); m_errorMonitor->VerifyFound(); // Invalid filter CUBIC_IMG + invalid 2D source image m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-filter-02002"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-filter-00237"); vk::CmdBlitImage(m_commandBuffer->handle(), src3D.image(), src3D.Layout(), dst2D.image(), dst2D.Layout(), 1, &blitRegion, VK_FILTER_CUBIC_IMG); m_errorMonitor->VerifyFound(); } m_commandBuffer->end(); } TEST_F(VkLayerTest, BlitImageLayout) { TEST_DESCRIPTION("Incorrect vkCmdBlitImage layouts"); ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); VkResult err; VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM; VkSubmitInfo submit_info = LvlInitStruct(); submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = &m_commandBuffer->handle(); // Create images VkImageObj img_src_transfer(m_device); VkImageObj img_dst_transfer(m_device); VkImageObj img_general(m_device); VkImageObj img_color(m_device); img_src_transfer.InitNoLayout(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); img_dst_transfer.InitNoLayout(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); img_general.InitNoLayout(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); img_color.InitNoLayout(64, 64, 1, fmt, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(img_src_transfer.initialized()); ASSERT_TRUE(img_dst_transfer.initialized()); ASSERT_TRUE(img_general.initialized()); ASSERT_TRUE(img_color.initialized()); img_src_transfer.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); img_dst_transfer.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); img_general.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); img_color.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); VkImageBlit blit_region = {}; blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.srcSubresource.baseArrayLayer = 0; blit_region.srcSubresource.layerCount = 1; blit_region.srcSubresource.mipLevel = 0; blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.dstSubresource.baseArrayLayer = 0; blit_region.dstSubresource.layerCount = 1; blit_region.dstSubresource.mipLevel = 0; blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.srcOffsets[1] = {32, 32, 1}; blit_region.dstOffsets[0] = {32, 32, 0}; blit_region.dstOffsets[1] = {64, 64, 1}; m_commandBuffer->begin(); vk::CmdBlitImage(m_commandBuffer->handle(), img_general.image(), img_general.Layout(), img_general.image(), img_general.Layout(), 1, &blit_region, VK_FILTER_LINEAR); // Illegal srcImageLayout m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImageLayout-00222"); vk::CmdBlitImage(m_commandBuffer->handle(), img_src_transfer.image(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, img_dst_transfer.image(), img_dst_transfer.Layout(), 1, &blit_region, VK_FILTER_LINEAR); m_errorMonitor->VerifyFound(); // Illegal destImageLayout m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImageLayout-00227"); vk::CmdBlitImage(m_commandBuffer->handle(), img_src_transfer.image(), img_src_transfer.Layout(), img_dst_transfer.image(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 1, &blit_region, VK_FILTER_LINEAR); m_commandBuffer->end(); vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); m_errorMonitor->VerifyFound(); err = vk::QueueWaitIdle(m_device->m_queue); ASSERT_VK_SUCCESS(err); m_commandBuffer->reset(0); m_commandBuffer->begin(); // Source image in invalid layout at start of the CB m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidImageLayout"); vk::CmdBlitImage(m_commandBuffer->handle(), img_src_transfer.image(), img_src_transfer.Layout(), img_color.image(), VK_IMAGE_LAYOUT_GENERAL, 1, &blit_region, VK_FILTER_LINEAR); m_commandBuffer->end(); vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); m_errorMonitor->VerifyFound(); err = vk::QueueWaitIdle(m_device->m_queue); ASSERT_VK_SUCCESS(err); m_commandBuffer->reset(0); m_commandBuffer->begin(); // Destination image in invalid layout at start of the CB m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidImageLayout"); vk::CmdBlitImage(m_commandBuffer->handle(), img_color.image(), VK_IMAGE_LAYOUT_GENERAL, img_dst_transfer.image(), img_dst_transfer.Layout(), 1, &blit_region, VK_FILTER_LINEAR); m_commandBuffer->end(); vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); m_errorMonitor->VerifyFound(); err = vk::QueueWaitIdle(m_device->m_queue); ASSERT_VK_SUCCESS(err); // Source image in invalid layout in the middle of CB m_commandBuffer->reset(0); m_commandBuffer->begin(); VkImageMemoryBarrier img_barrier = LvlInitStruct(); img_barrier.srcAccessMask = 0; img_barrier.dstAccessMask = 0; img_barrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL; img_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; img_barrier.image = img_general.handle(); 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; vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &img_barrier); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImageLayout-00221"); vk::CmdBlitImage(m_commandBuffer->handle(), img_general.image(), VK_IMAGE_LAYOUT_GENERAL, img_dst_transfer.image(), img_dst_transfer.Layout(), 1, &blit_region, VK_FILTER_LINEAR); m_commandBuffer->end(); vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); m_errorMonitor->VerifyFound(); err = vk::QueueWaitIdle(m_device->m_queue); ASSERT_VK_SUCCESS(err); // Destination image in invalid layout in the middle of CB m_commandBuffer->reset(0); m_commandBuffer->begin(); img_barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; img_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; img_barrier.image = img_dst_transfer.handle(); vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &img_barrier); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImageLayout-00226"); vk::CmdBlitImage(m_commandBuffer->handle(), img_src_transfer.image(), img_src_transfer.Layout(), img_dst_transfer.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_region, VK_FILTER_LINEAR); m_commandBuffer->end(); vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); m_errorMonitor->VerifyFound(); err = vk::QueueWaitIdle(m_device->m_queue); ASSERT_VK_SUCCESS(err); } TEST_F(VkLayerTest, BlitImageOffsets) { ASSERT_NO_FATAL_FAILURE(Init()); VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM; if (!ImageFormatAndFeaturesSupported(gpu(), fmt, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT)) { GTEST_SKIP() << "No blit feature format support"; } VkImageCreateInfo ci = LvlInitStruct(); ci.flags = 0; ci.imageType = VK_IMAGE_TYPE_1D; ci.format = fmt; ci.extent = {64, 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; VkImageObj image_1D(m_device); image_1D.init(&ci); ASSERT_TRUE(image_1D.initialized()); ci.imageType = VK_IMAGE_TYPE_2D; ci.extent = {64, 64, 1}; VkImageObj image_2D(m_device); image_2D.init(&ci); ASSERT_TRUE(image_2D.initialized()); ci.imageType = VK_IMAGE_TYPE_3D; ci.extent = {64, 64, 64}; VkImageObj image_3D(m_device); image_3D.init(&ci); ASSERT_TRUE(image_3D.initialized()); VkImageBlit blit_region = {}; blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.srcSubresource.baseArrayLayer = 0; blit_region.srcSubresource.layerCount = 1; blit_region.srcSubresource.mipLevel = 0; blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.dstSubresource.baseArrayLayer = 0; blit_region.dstSubresource.layerCount = 1; blit_region.dstSubresource.mipLevel = 0; m_commandBuffer->begin(); // 1D, with src/dest y offsets other than (0,1) blit_region.srcOffsets[0] = {0, 1, 0}; blit_region.srcOffsets[1] = {30, 1, 1}; blit_region.dstOffsets[0] = {32, 0, 0}; blit_region.dstOffsets[1] = {64, 1, 1}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00245"); vk::CmdBlitImage(m_commandBuffer->handle(), image_1D.image(), image_1D.Layout(), image_1D.image(), image_1D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.dstOffsets[0] = {32, 1, 0}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-00250"); vk::CmdBlitImage(m_commandBuffer->handle(), image_1D.image(), image_1D.Layout(), image_1D.image(), image_1D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // 2D, with src/dest z offsets other than (0,1) blit_region.srcOffsets[0] = {0, 0, 1}; blit_region.srcOffsets[1] = {24, 31, 1}; blit_region.dstOffsets[0] = {32, 32, 0}; blit_region.dstOffsets[1] = {64, 64, 1}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00247"); vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.dstOffsets[0] = {32, 32, 1}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-00252"); vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Source offsets exceeding source image dimensions blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.srcOffsets[1] = {65, 64, 1}; // src x blit_region.dstOffsets[0] = {0, 0, 0}; blit_region.dstOffsets[1] = {64, 64, 1}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00243"); // x m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00215"); // src region vk::CmdBlitImage(m_commandBuffer->handle(), image_3D.image(), image_3D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.srcOffsets[1] = {64, 65, 1}; // src y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00244"); // y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00215"); // src region vk::CmdBlitImage(m_commandBuffer->handle(), image_3D.image(), image_3D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.srcOffsets[0] = {0, 0, 65}; // src z blit_region.srcOffsets[1] = {64, 64, 64}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00246"); // z m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00215"); // src region vk::CmdBlitImage(m_commandBuffer->handle(), image_3D.image(), image_3D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Dest offsets exceeding source image dimensions blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.srcOffsets[1] = {64, 64, 1}; blit_region.dstOffsets[0] = {96, 64, 32}; // dst x blit_region.dstOffsets[1] = {64, 0, 33}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00248"); // x m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00216"); // dst region vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_3D.image(), image_3D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.dstOffsets[0] = {0, 65, 32}; // dst y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00249"); // y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00216"); // dst region vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_3D.image(), image_3D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blit_region.dstOffsets[0] = {0, 64, 65}; // dst z blit_region.dstOffsets[1] = {64, 0, 64}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00251"); // z m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00216"); // dst region vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_3D.image(), image_3D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, BlitImageOverlap) { TEST_DESCRIPTION("Try to blit an image on same region."); ASSERT_NO_FATAL_FAILURE(Init()); VkFormat fmt = VK_FORMAT_R8G8B8A8_UNORM; if (!ImageFormatAndFeaturesSupported(gpu(), fmt, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT)) { GTEST_SKIP() << "No blit feature format support"; } VkImageCreateInfo ci = LvlInitStruct(); ci.flags = 0; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = fmt; 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 = nullptr; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImageObj image_2D(m_device); image_2D.init(&ci); ASSERT_TRUE(image_2D.initialized()); VkImageBlit blit_region = {}; blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.srcSubresource.baseArrayLayer = 0; blit_region.srcSubresource.layerCount = 1; blit_region.srcSubresource.mipLevel = 0; blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.dstSubresource.baseArrayLayer = 0; blit_region.dstSubresource.layerCount = 1; blit_region.dstSubresource.mipLevel = 0; m_commandBuffer->begin(); blit_region.srcOffsets[0] = {0, 0, 0}; blit_region.srcOffsets[1] = {31, 31, 1}; blit_region.dstOffsets[0] = {15, 15, 0}; blit_region.dstOffsets[1] = {47, 47, 1}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00217"); vk::CmdBlitImage(m_commandBuffer->handle(), image_2D.image(), image_2D.Layout(), image_2D.image(), image_2D.Layout(), 1, &blit_region, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, MiscBlitImageTests) { ASSERT_NO_FATAL_FAILURE(Init()); VkFormat f_color = VK_FORMAT_R32_SFLOAT; // Need features ..BLIT_SRC_BIT & ..BLIT_DST_BIT if (!ImageFormatAndFeaturesSupported(gpu(), f_color, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT)) { GTEST_SKIP() << "No blit feature format support"; } VkImageCreateInfo ci = LvlInitStruct(); ci.flags = 0; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = f_color; 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; // 2D color image VkImageObj color_img(m_device); color_img.init(&ci); ASSERT_TRUE(color_img.initialized()); // 2D multi-sample image ci.samples = VK_SAMPLE_COUNT_4_BIT; VkImageObj ms_img(m_device); ms_img.init(&ci); ASSERT_TRUE(ms_img.initialized()); // 3D color image ci.samples = VK_SAMPLE_COUNT_1_BIT; ci.imageType = VK_IMAGE_TYPE_3D; ci.extent = {64, 64, 8}; VkImageObj color_3D_img(m_device); color_3D_img.init(&ci); ASSERT_TRUE(color_3D_img.initialized()); 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] = {0, 0, 0}; blitRegion.srcOffsets[1] = {16, 16, 1}; blitRegion.dstOffsets[0] = {32, 32, 0}; blitRegion.dstOffsets[1] = {64, 64, 1}; m_commandBuffer->begin(); // Blit with aspectMask errors blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-aspectMask-00241"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-aspectMask-00242"); vk::CmdBlitImage(m_commandBuffer->handle(), color_img.image(), color_img.Layout(), color_img.image(), color_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Blit with invalid src mip level blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blitRegion.srcSubresource.mipLevel = ci.mipLevels; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcSubresource-01705"); // invalid srcSubresource.mipLevel // Redundant unavoidable errors m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00243"); // out-of-bounds srcOffset.x m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00244"); // out-of-bounds srcOffset.y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcOffset-00246"); // out-of-bounds srcOffset.z m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00215"); // region not contained within src image vk::CmdBlitImage(m_commandBuffer->handle(), color_img.image(), color_img.Layout(), color_img.image(), color_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Blit with invalid dst mip level blitRegion.srcSubresource.mipLevel = 0; blitRegion.dstSubresource.mipLevel = ci.mipLevels; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstSubresource-01706"); // invalid dstSubresource.mipLevel // Redundant unavoidable errors m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00248"); // out-of-bounds dstOffset.x m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00249"); // out-of-bounds dstOffset.y m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstOffset-00251"); // out-of-bounds dstOffset.z m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-pRegions-00216"); // region not contained within dst image vk::CmdBlitImage(m_commandBuffer->handle(), color_img.image(), color_img.Layout(), color_img.image(), color_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Blit with invalid src array layer blitRegion.dstSubresource.mipLevel = 0; blitRegion.srcSubresource.baseArrayLayer = ci.arrayLayers; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcSubresource-01707"); // invalid srcSubresource layer range vk::CmdBlitImage(m_commandBuffer->handle(), color_img.image(), color_img.Layout(), color_img.image(), color_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Blit with invalid dst array layer blitRegion.srcSubresource.baseArrayLayer = 0; blitRegion.dstSubresource.baseArrayLayer = ci.arrayLayers; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstSubresource-01708"); // invalid dstSubresource layer range // Redundant unavoidable errors vk::CmdBlitImage(m_commandBuffer->handle(), color_img.image(), color_img.Layout(), color_img.image(), color_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blitRegion.dstSubresource.baseArrayLayer = 0; // Blit multi-sample image m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00233"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-00234"); vk::CmdBlitImage(m_commandBuffer->handle(), ms_img.image(), ms_img.Layout(), ms_img.image(), ms_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); // Blit 3D with baseArrayLayer != 0 or layerCount != 1 blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blitRegion.srcSubresource.baseArrayLayer = 1; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00240"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcSubresource-01707"); // base+count > total layer count vk::CmdBlitImage(m_commandBuffer->handle(), color_3D_img.image(), color_3D_img.Layout(), color_3D_img.image(), color_3D_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); blitRegion.srcSubresource.baseArrayLayer = 0; blitRegion.srcSubresource.layerCount = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-srcImage-00240"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-layerCount-01700"); // layer count == 0 (src) m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageBlit-layerCount-00239"); // src/dst layer count mismatch vk::CmdBlitImage(m_commandBuffer->handle(), color_3D_img.image(), color_3D_img.Layout(), color_3D_img.image(), color_3D_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, BlitToDepthImageTests) { ASSERT_NO_FATAL_FAILURE(Init()); PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { GTEST_SKIP() << "Failed to load device profile layer."; } VkFormat f_depth = VK_FORMAT_D32_SFLOAT; VkFormatProperties formatProps; fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), f_depth, &formatProps); formatProps.optimalTilingFeatures |= VK_FORMAT_FEATURE_BLIT_SRC_BIT; formatProps.optimalTilingFeatures = formatProps.optimalTilingFeatures & ~VK_FORMAT_FEATURE_BLIT_DST_BIT; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), f_depth, formatProps); VkImageCreateInfo ci = LvlInitStruct(); ci.flags = 0; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = f_depth; 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; // 2D depth image VkImageObj depth_img(m_device); depth_img.init(&ci); ASSERT_TRUE(depth_img.initialized()); 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] = {0, 0, 0}; blitRegion.srcOffsets[1] = {16, 16, 1}; blitRegion.dstOffsets[0] = {32, 32, 0}; blitRegion.dstOffsets[1] = {64, 64, 1}; m_commandBuffer->begin(); // Blit depth image - has SRC_BIT but not DST_BIT blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBlitImage-dstImage-02000"); vk::CmdBlitImage(m_commandBuffer->handle(), depth_img.image(), depth_img.Layout(), depth_img.image(), depth_img.Layout(), 1, &blitRegion, VK_FILTER_NEAREST); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, MinImageTransferGranularity) { TEST_DESCRIPTION("Tests for validation of Queue Family property minImageTransferGranularity."); ASSERT_NO_FATAL_FAILURE(Init()); auto queue_family_properties = m_device->phy().queue_properties(); auto large_granularity_family = std::find_if(queue_family_properties.begin(), queue_family_properties.end(), [](VkQueueFamilyProperties family_properties) { VkExtent3D family_granularity = family_properties.minImageTransferGranularity; // We need a queue family that supports copy operations and has a large enough minImageTransferGranularity for the tests // below to make sense. return (family_properties.queueFlags & VK_QUEUE_TRANSFER_BIT || family_properties.queueFlags & VK_QUEUE_GRAPHICS_BIT || family_properties.queueFlags & VK_QUEUE_COMPUTE_BIT) && family_granularity.depth >= 4 && family_granularity.width >= 4 && family_granularity.height >= 4; }); if (large_granularity_family == queue_family_properties.end()) { GTEST_SKIP() << "No queue family has a large enough granularity for this test to be meaningful"; } const size_t queue_family_index = std::distance(queue_family_properties.begin(), large_granularity_family); VkExtent3D granularity = queue_family_properties[queue_family_index].minImageTransferGranularity; VkCommandPoolObj command_pool(m_device, queue_family_index, 0); // Create two images of different types and try to copy between them VkImage srcImage; VkImage dstImage; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_3D; image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; image_create_info.extent.width = granularity.width * 2; image_create_info.extent.height = granularity.height * 2; image_create_info.extent.depth = granularity.depth * 2; 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_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_create_info.flags = 0; VkImageObj src_image_obj(m_device); src_image_obj.init(&image_create_info); ASSERT_TRUE(src_image_obj.initialized()); srcImage = src_image_obj.handle(); image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj dst_image_obj(m_device); dst_image_obj.init(&image_create_info); ASSERT_TRUE(dst_image_obj.initialized()); dstImage = dst_image_obj.handle(); VkCommandBufferObj command_buffer(m_device, &command_pool); ASSERT_TRUE(command_buffer.initialized()); command_buffer.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 = granularity.width; copyRegion.extent.height = granularity.height; copyRegion.extent.depth = granularity.depth; // Introduce failure by setting srcOffset to a bad granularity value copyRegion.srcOffset.y = 3; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity command_buffer.CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); m_errorMonitor->VerifyFound(); // Introduce failure by setting extent to a granularity value that is bad // for both the source and destination image. copyRegion.srcOffset.y = 0; copyRegion.extent.width = 3; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity command_buffer.CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); m_errorMonitor->VerifyFound(); // Now do some buffer/image copies VkBufferObj buffer; VkMemoryPropertyFlags reqs = 0; buffer.init_as_src_and_dst(*m_device, 8 * granularity.height * granularity.width * granularity.depth, reqs); VkBufferImageCopy region = {}; region.bufferOffset = 0; region.bufferRowLength = 0; region.bufferImageHeight = 0; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; region.imageSubresource.layerCount = 1; region.imageExtent.height = granularity.height; region.imageExtent.width = granularity.width; region.imageExtent.depth = granularity.depth; region.imageOffset.x = 0; region.imageOffset.y = 0; region.imageOffset.z = 0; // Introduce failure by setting imageExtent to a bad granularity value region.imageExtent.width = 3; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageOffset-07747"); // image transfer granularity vk::CmdCopyImageToBuffer(command_buffer.handle(), srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer.handle(), 1, ®ion); m_errorMonitor->VerifyFound(); region.imageExtent.width = granularity.width; // Introduce failure by setting imageOffset to a bad granularity value region.imageOffset.z = 3; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageOffset-07738"); // image transfer granularity vk::CmdCopyBufferToImage(command_buffer.handle(), buffer.handle(), dstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); m_errorMonitor->VerifyFound(); command_buffer.end(); } TEST_F(VkLayerTest, Bad2DArrayImageType) { TEST_DESCRIPTION("Create an image with a flag specifying 2D_ARRAY_COMPATIBLE but not of imageType 3D."); AddRequiredExtensions(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); // Trigger check by setting imagecreateflags to 2d_array_compat and imageType to 2D VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, {32, 32, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; CreateImageTest(*this, &ici, "VUID-VkImageCreateInfo-flags-00950"); } TEST_F(VkLayerTest, Bad2DViewImageType) { TEST_DESCRIPTION("Create an image with a flag specifying 2D_VIEW_COMPATIBLE but not of imageType 3D."); AddRequiredExtensions(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); AddRequiredExtensions(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); // Trigger check by setting imagecreateflags to 2d_array_compat and imageType to 2D VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, {32, 32, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; CreateImageTest(*this, &ici, "VUID-VkImageCreateInfo-flags-07755"); } // INVALID_IMAGE_LAYOUT tests (one other case is hit by MapMemWithoutHostVisibleBit and not here) TEST_F(VkLayerTest, InvalidImageLayout) { TEST_DESCRIPTION( "Hit all possible validation checks associated with the UNASSIGNED-CoreValidation-DrawState-InvalidImageLayout error. " "Generally these involve having images in the wrong layout when they're copied or transitioned."); // 3 in ValidateCmdBufImageLayouts // * -1 Attempt to submit cmd buf w/ deleted image // * -2 Cmd buf submit of image w/ layout not matching first use w/ subresource // * -3 Cmd buf submit of image w/ layout not matching first use w/o subresource SetTargetApiVersion(VK_API_VERSION_1_2); AddRequiredExtensions(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); const bool copy_commands2 = IsExtensionsEnabled(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } if (!CheckSynchronization2SupportAndInitState(this)) { GTEST_SKIP() << "Synchronization2 not supported"; } PFN_vkCmdCopyImage2KHR vkCmdCopyImage2Function = nullptr; if (copy_commands2) { vkCmdCopyImage2Function = (PFN_vkCmdCopyImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdCopyImage2KHR"); } auto depth_format = FindSupportedDepthStencilFormat(gpu()); // Create src & dst images to use for copy operations VkImageObj src_image(m_device); VkImageObj dst_image(m_device); VkImageObj depth_image(m_device); const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM; const int32_t tex_width = 32; const int32_t tex_height = 32; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = tex_format; image_create_info.extent.width = tex_width; image_create_info.extent.height = tex_height; 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.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.flags = 0; src_image.init(&image_create_info); image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; dst_image.init(&image_create_info); image_create_info.format = VK_FORMAT_D16_UNORM; image_create_info.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; depth_image.init(&image_create_info); m_commandBuffer->begin(); VkImageCopy copy_region; copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; copy_region.srcSubresource.mipLevel = 0; copy_region.srcSubresource.baseArrayLayer = 0; copy_region.srcSubresource.layerCount = 1; copy_region.srcOffset.x = 0; copy_region.srcOffset.y = 0; copy_region.srcOffset.z = 0; copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; copy_region.dstSubresource.mipLevel = 0; copy_region.dstSubresource.baseArrayLayer = 0; copy_region.dstSubresource.layerCount = 1; copy_region.dstOffset.x = 0; copy_region.dstOffset.y = 0; copy_region.dstOffset.z = 0; copy_region.extent.width = 1; copy_region.extent.height = 1; copy_region.extent.depth = 1; m_errorMonitor->SetDesiredFailureMsg(kPerformanceWarningBit, "layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); // The first call hits the expected WARNING and skips the call down the chain, so call a second time to call down chain and // update layer state m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); // Now cause error due to src image layout changing m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImageLayout-00128"); m_errorMonitor->SetUnexpectedError("is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT"); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); // Final src error is due to bad layout type m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImageLayout-00129"); m_errorMonitor->SetUnexpectedError( "with specific layout VK_IMAGE_LAYOUT_UNDEFINED that doesn't match the previously used layout VK_IMAGE_LAYOUT_GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); // Now verify same checks for dst m_errorMonitor->SetDesiredFailureMsg(kPerformanceWarningBit, "layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); // Now cause error due to src image layout changing m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImageLayout-00133"); m_errorMonitor->SetUnexpectedError( "is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, 1, ©_region); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstImageLayout-00134"); m_errorMonitor->SetUnexpectedError( "with specific layout VK_IMAGE_LAYOUT_UNDEFINED that doesn't match the previously used layout VK_IMAGE_LAYOUT_GENERAL."); m_commandBuffer->CopyImage(src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, 1, ©_region); m_errorMonitor->VerifyFound(); // Equivalent tests using KHR_copy_commands2 if (copy_commands2 && vkCmdCopyImage2Function) { const VkImageCopy2KHR copy_region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, NULL, copy_region.srcSubresource, copy_region.srcOffset, copy_region.dstSubresource, copy_region.dstOffset, copy_region.extent}; VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, NULL, src_image.handle(), VK_IMAGE_LAYOUT_GENERAL, dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region2}; m_errorMonitor->SetDesiredFailureMsg(kPerformanceWarningBit, "layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); // The first call hits the expected WARNING and skips the call down the chain, so call a second time to call down chain and // update layer state m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); // Now cause error due to src image layout changing m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcImageLayout-00128"); m_errorMonitor->SetUnexpectedError("is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT"); copy_image_info2.srcImageLayout = VK_IMAGE_LAYOUT_UNDEFINED; vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); // Final src error is due to bad layout type m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-srcImageLayout-00129"); m_errorMonitor->SetUnexpectedError( "with specific layout VK_IMAGE_LAYOUT_UNDEFINED that doesn't match the previously used layout " "VK_IMAGE_LAYOUT_GENERAL."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); // Now verify same checks for dst m_errorMonitor->SetDesiredFailureMsg(kPerformanceWarningBit, "layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL instead of GENERAL."); copy_image_info2.srcImageLayout = VK_IMAGE_LAYOUT_GENERAL; vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); // Now cause error due to src image layout changing m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstImageLayout-00133"); m_errorMonitor->SetUnexpectedError( "is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL."); copy_image_info2.dstImageLayout = VK_IMAGE_LAYOUT_UNDEFINED; vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCopyImageInfo2-dstImageLayout-00134"); m_errorMonitor->SetUnexpectedError( "with specific layout VK_IMAGE_LAYOUT_UNDEFINED that doesn't match the previously used layout " "VK_IMAGE_LAYOUT_GENERAL."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); } // Convert dst and depth images to TRANSFER_DST for subsequent tests VkImageMemoryBarrier transfer_dst_image_barrier[1] = {}; transfer_dst_image_barrier[0] = LvlInitStruct(); transfer_dst_image_barrier[0].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; transfer_dst_image_barrier[0].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; transfer_dst_image_barrier[0].srcAccessMask = 0; transfer_dst_image_barrier[0].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; transfer_dst_image_barrier[0].image = dst_image.handle(); transfer_dst_image_barrier[0].subresourceRange.layerCount = image_create_info.arrayLayers; transfer_dst_image_barrier[0].subresourceRange.levelCount = image_create_info.mipLevels; transfer_dst_image_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, transfer_dst_image_barrier); transfer_dst_image_barrier[0].image = depth_image.handle(); transfer_dst_image_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, transfer_dst_image_barrier); // Cause errors due to clearing with invalid image layouts VkClearColorValue color_clear_value = {}; VkImageSubresourceRange clear_range; clear_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; clear_range.baseMipLevel = 0; clear_range.baseArrayLayer = 0; clear_range.layerCount = 1; clear_range.levelCount = 1; // Fail due to explicitly prohibited layout for color clear (only GENERAL and TRANSFER_DST are permitted). // Since the image is currently not in UNDEFINED layout, this will emit two errors. m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-imageLayout-00005"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-imageLayout-00004"); m_commandBuffer->ClearColorImage(dst_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, &color_clear_value, 1, &clear_range); m_errorMonitor->VerifyFound(); // Fail due to provided layout not matching actual current layout for color clear. m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-imageLayout-00004"); m_commandBuffer->ClearColorImage(dst_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &color_clear_value, 1, &clear_range); m_errorMonitor->VerifyFound(); VkClearDepthStencilValue depth_clear_value = {}; clear_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; // Fail due to explicitly prohibited layout for depth clear (only GENERAL and TRANSFER_DST are permitted). // Since the image is currently not in UNDEFINED layout, this will emit two errors. m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-imageLayout-00012"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-imageLayout-00011"); m_commandBuffer->ClearDepthStencilImage(depth_image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, &depth_clear_value, 1, &clear_range); m_errorMonitor->VerifyFound(); // Fail due to provided layout not matching actual current layout for depth clear. m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-imageLayout-00011"); m_commandBuffer->ClearDepthStencilImage(depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &depth_clear_value, 1, &clear_range); m_errorMonitor->VerifyFound(); VkImageMemoryBarrier image_barrier[1] = {}; // In synchronization2, if oldLayout == newLayout, we're not doing an ILT and these fields don't need to match // the image's layout. image_barrier[0] = LvlInitStruct(); image_barrier[0].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_barrier[0].newLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_barrier[0].image = src_image.handle(); image_barrier[0].subresourceRange.layerCount = image_create_info.arrayLayers; image_barrier[0].subresourceRange.levelCount = image_create_info.mipLevels; image_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, image_barrier); // Now cause error due to bad image layout transition in PipelineBarrier image_barrier[0] = LvlInitStruct(); image_barrier[0].oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; image_barrier[0].newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; image_barrier[0].image = src_image.handle(); image_barrier[0].subresourceRange.layerCount = image_create_info.arrayLayers; image_barrier[0].subresourceRange.levelCount = image_create_info.mipLevels; image_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageMemoryBarrier-oldLayout-01197"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageMemoryBarrier-oldLayout-01210"); vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, image_barrier); m_errorMonitor->VerifyFound(); // Finally some layout errors at RenderPass create time // Just hacking in specific state to get to the errors we want so don't copy this unless you know what you're doing. VkAttachmentReference attach = {}; VkSubpassDescription subpass = {}; subpass.inputAttachmentCount = 0; subpass.colorAttachmentCount = 0; subpass.pDepthStencilAttachment = &attach; VkRenderPassCreateInfo rpci = LvlInitStruct(); rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.attachmentCount = 1; VkRenderPass rp; // For this error we need a valid renderpass so create default one attach.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; attach.attachment = 0; VkAttachmentDescription attach_desc = {}; attach_desc.format = depth_format; attach_desc.samples = VK_SAMPLE_COUNT_1_BIT; attach_desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE; attach_desc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attach_desc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; // Can't do a CLEAR load on READ_ONLY initialLayout attach_desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; attach_desc.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; attach_desc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; rpci.pAttachments = &attach_desc; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentDescription-format-03283"); vk::CreateRenderPass(m_device->device(), &rpci, NULL, &rp); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, InvalidStorageImageLayout) { TEST_DESCRIPTION("Attempt to update a STORAGE_IMAGE descriptor w/o GENERAL layout."); ASSERT_NO_FATAL_FAILURE(Init()); const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM; VkImageTiling tiling; VkFormatProperties format_properties; vk::GetPhysicalDeviceFormatProperties(gpu(), tex_format, &format_properties); if (format_properties.linearTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) { tiling = VK_IMAGE_TILING_LINEAR; } else if (format_properties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) { tiling = VK_IMAGE_TILING_OPTIMAL; } else { GTEST_SKIP() << "Device does not support VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; skipped."; } OneOffDescriptorSet descriptor_set(m_device, { {0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}, }); VkImageObj image(m_device); image.Init(32, 32, 1, tex_format, VK_IMAGE_USAGE_STORAGE_BIT, tiling, 0); ASSERT_TRUE(image.initialized()); VkImageView view = image.targetView(tex_format); descriptor_set.WriteDescriptorImageInfo(0, view, VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-04152"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, CopyInvalidImageMemory) { TEST_DESCRIPTION("Validate 4 invalid image memory VUIDs "); SetTargetApiVersion(VK_API_VERSION_1_1); AddOptionalExtensions(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool copy_commands2 = IsExtensionsEnabled(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME); PFN_vkCmdCopyImage2KHR vkCmdCopyImage2Function = nullptr; if (copy_commands2) { vkCmdCopyImage2Function = (PFN_vkCmdCopyImage2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCmdCopyImage2KHR"); } VkImageCreateInfo image_info = LvlInitStruct(); image_info.extent = {64, 64, 1}; image_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_info.imageType = VK_IMAGE_TYPE_2D; image_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_info.samples = VK_SAMPLE_COUNT_1_BIT; image_info.arrayLayers = 1; image_info.mipLevels = 1; // Create a small image with a dedicated allocation VkImageObj image_no_mem(m_device); image_no_mem.init_no_mem(*m_device, image_info); VkImageObj image(m_device); image.init(&image_info); VkImageCopy copy_region; copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; copy_region.srcSubresource.mipLevel = 0; copy_region.srcSubresource.baseArrayLayer = 0; copy_region.srcSubresource.layerCount = 1; copy_region.srcOffset.x = 0; copy_region.srcOffset.y = 0; copy_region.srcOffset.z = 0; copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; copy_region.dstSubresource.mipLevel = 0; copy_region.dstSubresource.baseArrayLayer = 0; copy_region.dstSubresource.layerCount = 1; copy_region.dstOffset.x = 0; copy_region.dstOffset.y = 0; copy_region.dstOffset.z = 0; copy_region.extent.width = 4; copy_region.extent.height = 4; copy_region.extent.depth = 1; std::string vuid; bool ycbcr = (IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) || (DeviceValidationVersion() >= VK_API_VERSION_1_1)); m_commandBuffer->begin(); vuid = ycbcr ? "VUID-vkCmdCopyImage-None-07923" : "VUID-vkCmdCopyImage-None-07922"; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); m_errorMonitor->SetUnexpectedError("is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT"); m_commandBuffer->CopyImage(image_no_mem.handle(), VK_IMAGE_LAYOUT_UNDEFINED, image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); vuid = ycbcr ? "VUID-vkCmdCopyImage-None-07923" : "VUID-vkCmdCopyImage-None-07922"; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); m_errorMonitor->SetUnexpectedError("is VK_IMAGE_LAYOUT_UNDEFINED but can only be VK_IMAGE_LAYOUT"); m_commandBuffer->CopyImage(image.handle(), VK_IMAGE_LAYOUT_UNDEFINED, image_no_mem.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); m_errorMonitor->VerifyFound(); if (copy_commands2 && vkCmdCopyImage2Function) { const VkImageCopy2KHR copy_region2 = {VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, NULL, copy_region.srcSubresource, copy_region.srcOffset, copy_region.dstSubresource, copy_region.dstOffset, copy_region.extent}; VkCopyImageInfo2KHR copy_image_info2 = {VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, NULL, image_no_mem.handle(), VK_IMAGE_LAYOUT_GENERAL, image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region2}; vuid = ycbcr ? "VUID-VkCopyImageInfo2-None-07923" : "VUID-VkCopyImageInfo2-None-07922"; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("doesn't match the previously used layout VK_IMAGE_LAYOUT_GENERAL."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); copy_image_info2.srcImage = image.handle(); copy_image_info2.dstImage = image_no_mem.handle(); vuid = ycbcr ? "VUID-VkCopyImageInfo2-None-07923" : "VUID-VkCopyImageInfo2-None-07922"; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); m_errorMonitor->SetUnexpectedError("layout should be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL instead of GENERAL."); m_errorMonitor->SetUnexpectedError("doesn't match the previously used layout VK_IMAGE_LAYOUT_GENERAL.."); vkCmdCopyImage2Function(m_commandBuffer->handle(), ©_image_info2); m_errorMonitor->VerifyFound(); } } TEST_F(VkLayerTest, CreateImageViewBreaksParameterCompatibilityRequirements) { TEST_DESCRIPTION( "Attempts to create an Image View with a view type that does not match the image type it is being created from."); AddOptionalExtensions(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool maintenance1_support = IsExtensionsEnabled(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); VkPhysicalDeviceMemoryProperties memProps; vk::GetPhysicalDeviceMemoryProperties(m_device->phy().handle(), &memProps); // Test mismatch detection for image of type VK_IMAGE_TYPE_1D VkImageCreateInfo imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_1D, VK_FORMAT_R8G8B8A8_UNORM, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image1D(m_device); image1D.init(&imgInfo); ASSERT_TRUE(image1D.initialized()); // Initialize VkImageViewCreateInfo with mismatched viewType VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image1D.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message CreateImageViewTest(*this, &ivci, "vkCreateImageView(): pCreateInfo->viewType VK_IMAGE_VIEW_TYPE_2D is not compatible with image"); // Test mismatch detection for image of type VK_IMAGE_TYPE_2D imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, {1, 1, 1}, 1, 6, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image2D(m_device); image2D.init(&imgInfo); ASSERT_TRUE(image2D.initialized()); // Initialize VkImageViewCreateInfo with mismatched viewType ivci = LvlInitStruct(); ivci.image = image2D.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_3D; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message CreateImageViewTest(*this, &ivci, "vkCreateImageView(): pCreateInfo->viewType VK_IMAGE_VIEW_TYPE_3D is not compatible with image"); // Change VkImageViewCreateInfo to different mismatched viewType ivci.viewType = VK_IMAGE_VIEW_TYPE_CUBE; ivci.subresourceRange.layerCount = 6; // Test for error message CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01003"); // Test mismatch detection for image of type VK_IMAGE_TYPE_3D imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_3D, VK_FORMAT_R8G8B8A8_UNORM, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image3D(m_device); image3D.init(&imgInfo); ASSERT_TRUE(image3D.initialized()); // Initialize VkImageViewCreateInfo with mismatched viewType ivci = LvlInitStruct(); ivci.image = image3D.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_1D; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message CreateImageViewTest(*this, &ivci, "vkCreateImageView(): pCreateInfo->viewType VK_IMAGE_VIEW_TYPE_1D is not compatible with image"); // Change VkImageViewCreateInfo to different mismatched viewType ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; // Test for error message if (maintenance1_support) { CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-06727"); } else { CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-subResourceRange-01021"); } // Check if the device can make the image required for this test case. VkImageFormatProperties formProps = {{0, 0, 0}, 0, 0, 0, 0}; VkResult res = vk::GetPhysicalDeviceImageFormatProperties( m_device->phy().handle(), VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_SPARSE_BINDING_BIT, &formProps); // If not, skip this part of the test. if (res || !m_device->phy().features().sparseBinding || !maintenance1_support) { GTEST_SKIP() << "Missing supported features"; } // Initialize VkImageCreateInfo with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR and VK_IMAGE_CREATE_SPARSE_BINDING_BIT which // are incompatible create flags. imgInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_TYPE_3D, VK_FORMAT_R8G8B8A8_UNORM, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImage imageSparse; // Creating a sparse image means we should not bind memory to it. res = vk::CreateImage(m_device->device(), &imgInfo, NULL, &imageSparse); ASSERT_FALSE(res); // Initialize VkImageViewCreateInfo to create a view that will attempt to utilize VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR. ivci = LvlInitStruct(); ivci.image = imageSparse; ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message CreateImageViewTest(*this, &ivci, " when the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or " "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags are enabled."); // Clean up vk::DestroyImage(m_device->device(), imageSparse, nullptr); } TEST_F(VkLayerTest, CreateImageViewFormatFeatureMismatch) { TEST_DESCRIPTION("Create view with a format that does not have the same features as the image format."); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); ASSERT_NO_FATAL_FAILURE(InitState()); PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { GTEST_SKIP() << "Failed to load device profile layer."; } uint32_t feature_count = 5; // List of features to be tested VkFormatFeatureFlagBits features[] = { VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, // 02274 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, // 02652 - only need one of 2 features VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, // 02275 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, // 02276 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT // 02277 }; // List of usage cases for each feature test VkImageUsageFlags usages[] = { VK_IMAGE_USAGE_SAMPLED_BIT, // 02274 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, // 02652 VK_IMAGE_USAGE_STORAGE_BIT, // 02275 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // 02276 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT // 02277 }; // List of errors that will be thrown in order of tests run // Order is done to make sure adjacent format features are different std::string optimal_error_codes[] = { "VUID-VkImageViewCreateInfo-usage-02274", "VUID-VkImageViewCreateInfo-usage-02652", "VUID-VkImageViewCreateInfo-usage-02275", "VUID-VkImageViewCreateInfo-usage-02276", "VUID-VkImageViewCreateInfo-usage-02277", // Needs to be last since needs special format }; VkFormatProperties formatProps; // All but one test in this loop and do last test after for special format case uint32_t i = 0; for (i = 0; i < (feature_count - 1); i++) { // Modify formats to have mismatched features // Format for image fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_UINT, &formatProps); formatProps.optimalTilingFeatures |= features[i]; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_UINT, formatProps); memset(&formatProps, 0, sizeof(formatProps)); // Format for view fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_SINT, &formatProps); formatProps.optimalTilingFeatures = features[(i + 1) % feature_count]; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_SINT, formatProps); // Create image with modified format VkImageCreateInfo imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R32G32B32A32_UINT, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, usages[i], VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image(m_device); image.init(&imgInfo); ASSERT_TRUE(image.initialized()); // Initialize VkImageViewCreateInfo with modified format VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R32G32B32A32_SINT; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message CreateImageViewTest(*this, &ivci, optimal_error_codes[i]); } // Test for VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT. Needs special formats // Only run this test if format supported if (!ImageFormatIsSupported(gpu(), VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_TILING_OPTIMAL)) { GTEST_SKIP() << "VK_FORMAT_D24_UNORM_S8_UINT format not supported"; } // Modify formats to have mismatched features // Format for image fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D24_UNORM_S8_UINT, &formatProps); formatProps.optimalTilingFeatures |= features[i]; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D24_UNORM_S8_UINT, formatProps); memset(&formatProps, 0, sizeof(formatProps)); // Format for view fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProps); formatProps.optimalTilingFeatures = features[(i + 1) % feature_count]; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D32_SFLOAT_S8_UINT, formatProps); // Create image with modified format VkImageCreateInfo imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_D24_UNORM_S8_UINT, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, usages[i], VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image(m_device); image.init(&imgInfo); ASSERT_TRUE(image.initialized()); // Initialize VkImageViewCreateInfo with modified format VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_D32_SFLOAT_S8_UINT; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; // The 02277 VU is 'probably' redundant, but keeping incase a future spec change // This extra VU checked is because depth formats are only compatible with themselves m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-01018"); // Test for error message CreateImageViewTest(*this, &ivci, optimal_error_codes[i]); } TEST_F(VkLayerTest, InvalidImageViewUsageCreateInfo) { TEST_DESCRIPTION("Usage modification via a chained VkImageViewUsageCreateInfo struct"); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { GTEST_SKIP() << "Failed to load device profile layer."; } VkFormatProperties formatProps; // Ensure image format claims support for sampled and storage, excludes color attachment memset(&formatProps, 0, sizeof(formatProps)); fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_UINT, &formatProps); formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT); formatProps.optimalTilingFeatures = formatProps.optimalTilingFeatures & ~VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_UINT, formatProps); // Create image with sampled and storage usages VkImageCreateInfo imgInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R32G32B32A32_UINT, {1, 1, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj image(m_device); image.init(&imgInfo); ASSERT_TRUE(image.initialized()); // Force the imageview format to exclude storage feature, include color attachment memset(&formatProps, 0, sizeof(formatProps)); fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_SINT, &formatProps); formatProps.optimalTilingFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; formatProps.optimalTilingFeatures = (formatProps.optimalTilingFeatures & ~VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT); fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32G32B32A32_SINT, formatProps); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R32G32B32A32_SINT; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // ImageView creation should fail because view format doesn't support all the underlying image's usages CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-usage-02275"); // Add a chained VkImageViewUsageCreateInfo to override original image usage bits, removing storage VkImageViewUsageCreateInfo usage_ci = LvlInitStruct(); usage_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT; // Link the VkImageViewUsageCreateInfo struct into the view's create info pNext chain ivci.pNext = &usage_ci; // ImageView should now succeed without error CreateImageViewTest(*this, &ivci); // Try a zero usage field usage_ci.usage = 0; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask"); // Try an illegal bit in usage field usage_ci.usage = 0x10000000 | VK_IMAGE_USAGE_SAMPLED_BIT; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewUsageCreateInfo-usage-parameter"); } TEST_F(VkLayerTest, CreateImageViewNoSeparateStencilUsage) { TEST_DESCRIPTION("Verify CreateImageView create info for the case VK_EXT_separate_stencil_usage is not supported."); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } const auto depth_format = FindSupportedDepthStencilFormat(gpu()); // without VK_EXT_separate_stencil_usage explicitly enabled ASSERT_NO_FATAL_FAILURE(InitState()); const VkImageAspectFlags aspect = VK_IMAGE_ASPECT_STENCIL_BIT; const VkImageSubresourceRange range = {aspect, 0, 1, 0, 1}; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.flags = 0; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = depth_format; image_create_info.extent = {64, 64, 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; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = nullptr; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImageViewCreateInfo image_view_create_info = LvlInitStruct(); image_view_create_info.flags = 0; image_view_create_info.image = VK_NULL_HANDLE; image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = depth_format; image_view_create_info.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}; image_view_create_info.subresourceRange = range; VkImageViewUsageCreateInfo image_view_usage_create_info = LvlInitStruct(); image_view_usage_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_view_create_info.pNext = &image_view_usage_create_info; VkImageObj image(m_device); image.init(&image_create_info); ASSERT_TRUE(image.initialized()); image_view_create_info.image = image.handle(); image_view_usage_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; // Extra flag // VkImageViewUsageCreateInfo::usage must not include any bits that were not set in VkImageCreateInfo::usage CreateImageViewTest(*this, &image_view_create_info, "VUID-VkImageViewCreateInfo-pNext-02661"); } TEST_F(VkLayerTest, CreateImageViewStencilUsageCreateInfo) { TEST_DESCRIPTION("Verify CreateImageView with stencil usage."); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); AddRequiredExtensions(VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } const auto depth_format = FindSupportedDepthStencilFormat(gpu()); ASSERT_NO_FATAL_FAILURE(InitState()); const VkImageAspectFlags aspect = VK_IMAGE_ASPECT_STENCIL_BIT; const VkImageSubresourceRange range = {aspect, 0, 1, 0, 1}; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.flags = 0; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = depth_format; image_create_info.extent = {64, 64, 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; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = nullptr; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImageViewCreateInfo image_view_create_info = LvlInitStruct(); image_view_create_info.flags = 0; image_view_create_info.image = VK_NULL_HANDLE; image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = depth_format; image_view_create_info.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}; image_view_create_info.subresourceRange = range; VkImageViewUsageCreateInfo image_view_usage_create_info = LvlInitStruct(); image_view_usage_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_view_create_info.pNext = &image_view_usage_create_info; VkImageObj image(m_device); image.init(&image_create_info); ASSERT_TRUE(image.initialized()); image_view_create_info.image = image.handle(); image_view_usage_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; // Extra flag // VkImageViewUsageCreateInfo::usage must not include any bits that were not set in VkImageCreateInfo::usage CreateImageViewTest(*this, &image_view_create_info, "VUID-VkImageViewCreateInfo-pNext-02662"); VkImageStencilUsageCreateInfoEXT image_stencil_create_info = LvlInitStruct(); image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.pNext = &image_stencil_create_info; image_view_usage_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; // Extra flag image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; // Flag other than VK_IMAGE_ASPECT_STENCIL_BIT VkImageObj image2(m_device); image2.init(&image_create_info); ASSERT_TRUE(image2.initialized()); image_view_create_info.image = image2.handle(); VkImageView view = VK_NULL_HANDLE; // VkImageViewUsageCreateInfo::usage must not include any bits that were not set in // VkImageStencilUsageCreateInfo::stencilUsage m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-pNext-02663"); // VkImageViewUsageCreateInfo::usage must not include any bits that were not set in VkImageCreateInfo::usage m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-pNext-02664"); VkResult err = vk::CreateImageView(m_device->device(), &image_view_create_info, nullptr, &view); m_errorMonitor->VerifyFound(); if (VK_SUCCESS == err) { vk::DestroyImageView(m_device->device(), view, nullptr); } } TEST_F(VkLayerTest, CreateImageViewNoMemoryBoundToImage) { VkResult err; ASSERT_NO_FATAL_FAILURE(Init()); // Create an image and try to create a view with no memory backing the image VkImage image; const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM; const int32_t tex_width = 32; const int32_t tex_height = 32; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = tex_format; image_create_info.extent.width = tex_width; image_create_info.extent.height = tex_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; image_create_info.flags = 0; err = vk::CreateImage(m_device->device(), &image_create_info, NULL, &image); ASSERT_VK_SUCCESS(err); VkImageViewCreateInfo image_view_create_info = LvlInitStruct(); image_view_create_info.image = image; image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = tex_format; image_view_create_info.subresourceRange.layerCount = 1; image_view_create_info.subresourceRange.baseMipLevel = 0; image_view_create_info.subresourceRange.levelCount = 1; image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; CreateImageViewTest(*this, &image_view_create_info, " used with no memory bound. Memory should be bound by calling vkBindImageMemory()."); vk::DestroyImage(m_device->device(), image, NULL); } TEST_F(VkLayerTest, InvalidImageViewAspect) { TEST_DESCRIPTION("Create an image and try to create a view with an invalid aspectMask"); ASSERT_NO_FATAL_FAILURE(Init()); const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM; VkImageObj image(m_device); image.Init(32, 32, 1, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_LINEAR, 0); ASSERT_TRUE(image.initialized()); VkImageViewCreateInfo image_view_create_info = LvlInitStruct(); image_view_create_info.image = image.handle(); image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = tex_format; image_view_create_info.subresourceRange.baseMipLevel = 0; image_view_create_info.subresourceRange.levelCount = 1; image_view_create_info.subresourceRange.layerCount = 1; // Cause an error by setting an invalid image aspect image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT; CreateImageViewTest(*this, &image_view_create_info, "UNASSIGNED-CoreValidation-DrawState-InvalidImageAspect"); } TEST_F(VkLayerTest, ExerciseGetImageSubresourceLayout) { TEST_DESCRIPTION("Test vkGetImageSubresourceLayout() valid usages"); ASSERT_NO_FATAL_FAILURE(Init()); VkSubresourceLayout subres_layout = {}; // VU 00732: image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR { const VkImageTiling tiling = VK_IMAGE_TILING_OPTIMAL; // ERROR: violates VU 00732 VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, tiling); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subres.mipLevel = 0; subres.arrayLayer = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-image-07789"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } // VU 00733: The aspectMask member of pSubresource must only have a single bit set { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_METADATA_BIT; // ERROR: triggers VU 00733 subres.mipLevel = 0; subres.arrayLayer = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-aspectMask-00997"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04461"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } // 00739 mipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subres.mipLevel = 1; // ERROR: triggers VU 00739 subres.arrayLayer = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-mipLevel-01716"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } // 00740 arrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when the image was created { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; subres.mipLevel = 0; subres.arrayLayer = 1; // ERROR: triggers VU 00740 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-arrayLayer-01717"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } // 04462 If format has a depth component the aspectMask member of pResource must containt VK_IMAGE_ASPECT_DEPTH_BIT { VkFormat format = VK_FORMAT_D32_SFLOAT; VkFormatProperties image_format_properties; vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &image_format_properties); VkImageFormatProperties format_limits{}; VkResult result = vk::GetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0, &format_limits); if ((result == VK_SUCCESS) && ImageFormatAndFeaturesSupported(gpu(), format, VK_IMAGE_TILING_LINEAR, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // ERROR: triggers VU 04462 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04462"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } } // 04463 If format has a stencil component the aspectMask member of pResource must containt VK_IMAGE_ASPECT_STENCIL_BIT { VkFormat format = VK_FORMAT_S8_UINT; VkFormatProperties image_format_properties; vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &image_format_properties); VkImageFormatProperties format_limits{}; VkResult result = vk::GetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0, &format_limits); if ((result == VK_SUCCESS) && ImageFormatAndFeaturesSupported(gpu(), format, VK_IMAGE_TILING_LINEAR, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // ERROR: triggers VU 04463 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04463"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } } // 04464 If format does not contain stencil or depth component the aspectMask member of pResource must not contain // VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; // ERROR: triggers VU 00997 and 04464 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04461"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04464"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } { VkImageObj img(m_device); img.InitNoLayout(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT); ASSERT_TRUE(img.initialized()); VkImageSubresource subres = {}; subres.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; // ERROR: triggers VU 00997 and 04464 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04461"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-format-04464"); vk::GetImageSubresourceLayout(m_device->device(), img.image(), &subres, &subres_layout); m_errorMonitor->VerifyFound(); } } TEST_F(VkLayerTest, ImageLayerUnsupportedFormat) { TEST_DESCRIPTION("Creating images with unsupported formats "); ASSERT_NO_FATAL_FAILURE(Init()); ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); // Create image with unsupported format - Expect FORMAT_UNSUPPORTED VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_UNDEFINED; 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_OPTIMAL; image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-00943"); } TEST_F(VkLayerTest, CreateImageViewFormatMismatchUnrelated) { TEST_DESCRIPTION("Create an image with a color format, then try to create a depth view of it"); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); ASSERT_NO_FATAL_FAILURE(InitState()); PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { GTEST_SKIP() << "Failed to load device profile layer."; } auto depth_format = FindSupportedDepthStencilFormat(gpu()); VkFormatProperties formatProps; fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), depth_format, &formatProps); formatProps.optimalTilingFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), depth_format, formatProps); VkImageObj image(m_device); image.Init(128, 128, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkImageViewCreateInfo imgViewInfo = LvlInitStruct(); imgViewInfo.image = image.handle(); imgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imgViewInfo.format = depth_format; imgViewInfo.subresourceRange.layerCount = 1; imgViewInfo.subresourceRange.baseMipLevel = 0; imgViewInfo.subresourceRange.levelCount = 1; imgViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Can't use depth format for view into color image - Expect INVALID_FORMAT CreateImageViewTest(*this, &imgViewInfo, "Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation."); } TEST_F(VkLayerTest, CreateImageViewNoMutableFormatBit) { TEST_DESCRIPTION("Create an image view with a different format, when the image does not have MUTABLE_FORMAT bit"); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); ASSERT_NO_FATAL_FAILURE(InitState()); PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { GTEST_SKIP() << "Failed to load device profile layer."; } VkImageObj image(m_device); image.Init(128, 128, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkFormatProperties formatProps; fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_B8G8R8A8_UINT, &formatProps); formatProps.optimalTilingFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_B8G8R8A8_UINT, formatProps); VkImageViewCreateInfo imgViewInfo = LvlInitStruct(); imgViewInfo.image = image.handle(); imgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imgViewInfo.format = VK_FORMAT_B8G8R8A8_UINT; imgViewInfo.subresourceRange.layerCount = 1; imgViewInfo.subresourceRange.baseMipLevel = 0; imgViewInfo.subresourceRange.levelCount = 1; imgViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Same compatibility class but no MUTABLE_FORMAT bit - Expect // VIEW_CREATE_ERROR CreateImageViewTest(*this, &imgViewInfo, "VUID-VkImageViewCreateInfo-image-01019"); } TEST_F(VkLayerTest, CreateImageViewDifferentClass) { TEST_DESCRIPTION("Passing bad parameters to CreateImageView"); VkPhysicalDeviceFeatures device_features = {}; ASSERT_NO_FATAL_FAILURE(Init()); ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); if (!(m_device->format_properties(VK_FORMAT_R8_UINT).optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { GTEST_SKIP() << "Device does not support R8_UINT as color attachment"; } VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, 0, VK_IMAGE_TYPE_2D, VK_FORMAT_R8_UINT, {128, 128, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; imageInfo.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; VkImageObj mutImage(m_device); mutImage.init(&imageInfo); ASSERT_TRUE(mutImage.initialized()); VkImageViewCreateInfo imgViewInfo = LvlInitStruct(); imgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imgViewInfo.format = VK_FORMAT_B8G8R8A8_UNORM; // different than createImage imgViewInfo.subresourceRange.layerCount = 1; imgViewInfo.subresourceRange.baseMipLevel = 0; imgViewInfo.subresourceRange.levelCount = 1; imgViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imgViewInfo.image = mutImage.handle(); // Create mutable format image that is not compatiable bool ycbcr_support = (IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) || (DeviceValidationVersion() >= VK_API_VERSION_1_1)); bool maintenance2_support = (IsExtensionsEnabled(VK_KHR_MAINTENANCE_2_EXTENSION_NAME) || (DeviceValidationVersion() >= VK_API_VERSION_1_1)); const char *error_vuid; if ((!maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01018"; } else if ((maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01759"; } else if ((!maintenance2_support) && (ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01760"; } else { // both enabled error_vuid = "VUID-VkImageViewCreateInfo-image-01761"; } CreateImageViewTest(*this, &imgViewInfo, error_vuid); // Use CUBE_ARRAY without feature enabled if (device_features.imageCubeArray == false) { VkImageCreateInfo cubeImageInfo = imageInfo; cubeImageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; VkImageObj cubeImage(m_device); cubeImage.init(&cubeImageInfo); ASSERT_TRUE(cubeImage.initialized()); VkImageViewCreateInfo cubeImgViewInfo = imgViewInfo; cubeImgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; cubeImgViewInfo.format = VK_FORMAT_R8_UINT; // compatiable format cubeImgViewInfo.image = cubeImage.handle(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-viewType-02961"); CreateImageViewTest(*this, &cubeImgViewInfo, "VUID-VkImageViewCreateInfo-viewType-01004"); } } TEST_F(VkLayerTest, MultiplaneIncompatibleViewFormat) { TEST_DESCRIPTION("Postive/negative tests of multiplane imageview format compatibility"); // Use 1.1 to get VK_KHR_sampler_ycbcr_conversion easier SetTargetApiVersion(VK_API_VERSION_1_2); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required"; } // This test hits a bug in the driver, CTS was written, but incase using an old driver if (IsDriver(VK_DRIVER_ID_NVIDIA_PROPRIETARY)) { GTEST_SKIP() << "This test should not be run on the NVIDIA proprietary driver."; } auto features11 = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(features11); if (features11.samplerYcbcrConversion != VK_TRUE) { printf("samplerYcbcrConversion not supported, skipping test\n"); return; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); if (!ImageFormatAndFeaturesSupported(gpu(), VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT)) { GTEST_SKIP() << "Required formats/features not supported"; } VkSamplerYcbcrConversionCreateInfo ycbcr_create_info = LvlInitStruct(); ycbcr_create_info.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; ycbcr_create_info.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; ycbcr_create_info.ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL; ycbcr_create_info.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}; ycbcr_create_info.xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN; ycbcr_create_info.yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN; ycbcr_create_info.chromaFilter = VK_FILTER_NEAREST; ycbcr_create_info.forceExplicitReconstruction = false; VkSamplerYcbcrConversion conversion; vk::CreateSamplerYcbcrConversion(m_device->device(), &ycbcr_create_info, nullptr, &conversion); VkSamplerYcbcrConversionInfo ycbcr_info = LvlInitStruct(); ycbcr_info.conversion = conversion; VkImageCreateInfo ci = LvlInitStruct(); ci.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; ci.tiling = VK_IMAGE_TILING_OPTIMAL; ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT; ci.extent = {128, 128, 1}; ci.mipLevels = 1; ci.arrayLayers = 1; ci.samples = VK_SAMPLE_COUNT_1_BIT; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; const VkFormatFeatureFlags features = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); // Verify format 3 Plane format if (!supported) { printf("Multiplane image format not supported. Skipping test.\n"); } else { VkImageObj image_obj(m_device); image_obj.init(&ci); ASSERT_TRUE(image_obj.initialized()); VkImageViewCreateInfo ivci = LvlInitStruct(&ycbcr_info); ivci.image = image_obj.image(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8_UNORM; // Compat is VK_FORMAT_R8_UNORM ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; // Incompatible format error CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01586"); // Correct format succeeds ivci.format = VK_FORMAT_R8_UNORM; CreateImageViewTest(*this, &ivci); // R8_SNORM is compatible with R8_UNORM ivci.format = VK_FORMAT_R8_SNORM; CreateImageViewTest(*this, &ivci); // Try a multiplane imageview ivci.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; CreateImageViewTest(*this, &ivci); } ci.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); // Verify format 2 Plane format if (!supported) { printf("Multiplane image format not supported. Skipping test.\n"); } else { VkImageObj image_obj(m_device); image_obj.init(&ci); ASSERT_TRUE(image_obj.initialized()); VkImageViewCreateInfo ivci = LvlInitStruct(&ycbcr_info); ivci.image = image_obj.image(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; // Plane 0 is compatible with VK_FORMAT_R8_UNORM // Plane 1 is compatible with VK_FORMAT_R8G8_UNORM // Correct format succeeds ivci.format = VK_FORMAT_R8_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; CreateImageViewTest(*this, &ivci); ivci.format = VK_FORMAT_R8G8_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; CreateImageViewTest(*this, &ivci); // Incompatible format error ivci.format = VK_FORMAT_R8_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01586"); ivci.format = VK_FORMAT_R8G8_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01586"); } vk::DestroySamplerYcbcrConversion(m_device->device(), conversion, nullptr); } TEST_F(VkLayerTest, CreateImageViewInvalidSubresourceRange) { TEST_DESCRIPTION("Passing bad image subrange to CreateImageView"); ASSERT_NO_FATAL_FAILURE(Init()); const bool maintenance1 = IsExtensionsEnabled(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); VkPhysicalDeviceFeatures device_features = {}; ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); VkImageObj image(m_device); image.Init(32, 32, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL); ASSERT_TRUE(image.create_info().arrayLayers == 1); ASSERT_TRUE(image.initialized()); VkImageViewCreateInfo img_view_info_template = LvlInitStruct(); img_view_info_template.image = image.handle(); img_view_info_template.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info_template.format = image.format(); // subresourceRange to be filled later for the purposes of this test img_view_info_template.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; img_view_info_template.subresourceRange.baseMipLevel = 0; img_view_info_template.subresourceRange.levelCount = 0; img_view_info_template.subresourceRange.baseArrayLayer = 0; img_view_info_template.subresourceRange.layerCount = 0; auto const base_layer_vuid = maintenance1 ? "VUID-VkImageViewCreateInfo-image-01482" : "VUID-VkImageViewCreateInfo-subresourceRange-01480"; auto const layer_count_vuid = maintenance1 ? "VUID-VkImageViewCreateInfo-subresourceRange-01483" : "VUID-VkImageViewCreateInfo-subresourceRange-01719"; // Try baseMipLevel >= image.mipLevels with VK_REMAINING_MIP_LEVELS { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 1, VK_REMAINING_MIP_LEVELS, 0, 1}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-01478"); } // Try baseMipLevel >= image.mipLevels without VK_REMAINING_MIP_LEVELS { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 1, 1, 0, 1}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-subresourceRange-01718"); CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-01478"); } // Try levelCount = 0 { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 0, 1}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageSubresourceRange-levelCount-01720"); } // Try baseMipLevel + levelCount > image.mipLevels { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 2, 0, 1}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-01718"); } // Try baseArrayLayer >= image.arrayLayers with VK_REMAINING_ARRAY_LAYERS { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 1, VK_REMAINING_ARRAY_LAYERS}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, base_layer_vuid); } // Try baseArrayLayer >= image.arrayLayers without VK_REMAINING_ARRAY_LAYERS { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 1, 1}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, layer_count_vuid); CreateImageViewTest(*this, &img_view_info, base_layer_vuid); } // Try layerCount = 0 { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 0}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageSubresourceRange-layerCount-01721"); } // Try baseArrayLayer + layerCount > image.arrayLayers { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 2}; VkImageViewCreateInfo img_view_info = img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, layer_count_vuid); } { VkImageObj cubeArrayImg(m_device); auto image_ci = vk_testing::Image::create_info(); image_ci.arrayLayers = 18; image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; image_ci.imageType = VK_IMAGE_TYPE_2D; image_ci.format = VK_FORMAT_R8G8B8A8_UNORM; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; cubeArrayImg.init(&image_ci); VkImageViewCreateInfo cube_img_view_info_template = LvlInitStruct(); cube_img_view_info_template.image = cubeArrayImg.handle(); cube_img_view_info_template.viewType = VK_IMAGE_VIEW_TYPE_CUBE; cube_img_view_info_template.format = cubeArrayImg.format(); // subresourceRange to be filled later for the purposes of this test cube_img_view_info_template.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; cube_img_view_info_template.subresourceRange.baseMipLevel = 0; cube_img_view_info_template.subresourceRange.levelCount = 0; cube_img_view_info_template.subresourceRange.baseArrayLayer = 0; cube_img_view_info_template.subresourceRange.layerCount = 0; { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 6}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 5}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-viewType-02960"); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 12, VK_REMAINING_ARRAY_LAYERS}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 6, VK_REMAINING_ARRAY_LAYERS}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-viewType-02962"); } if (device_features.imageCubeArray == VK_TRUE) { { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 12}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 13}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-viewType-02961"); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 6, VK_REMAINING_ARRAY_LAYERS}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 11, VK_REMAINING_ARRAY_LAYERS}; VkImageViewCreateInfo img_view_info = cube_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-viewType-02963"); } } } { VkImageObj volumeImage(m_device); auto image_ci = vk_testing::Image::create_info(); image_ci.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR; image_ci.imageType = VK_IMAGE_TYPE_3D; image_ci.format = VK_FORMAT_R8G8B8A8_UNORM; image_ci.extent = {8, 8, 8}; image_ci.mipLevels = 4; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; volumeImage.init(&image_ci); VkImageViewCreateInfo volume_img_view_info_template = LvlInitStruct(); volume_img_view_info_template.image = volumeImage.handle(); volume_img_view_info_template.format = volumeImage.format(); // 3D views { // first mip { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // all mips { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 4, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // too many mips { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 5, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-01718"); } // invalid base mip { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 5, 1, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-subresourceRange-01718"); CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-01478"); } // too many layers { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 2}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-imageViewType-04973"); CreateImageViewTest(*this, &img_view_info, layer_count_vuid); } // invalid base layer { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 1, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_3D; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, layer_count_vuid); CreateImageViewTest(*this, &img_view_info, base_layer_vuid); } } if (maintenance1) { // 2D views // first mip, first layer { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // all mips, first layer (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 4, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-image-04970"); } // first mip, all layers (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 8}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-imageViewType-04973"); } // mip 3, 8 layers (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 3, 1, 0, 8}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-imageViewType-04973"); CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-02725"); } // mip 3, layer 7 (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 3, 1, 7, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-02724"); CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-02725"); } // 2D array views // first mip, first layer { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // all mips, first layer (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 4, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-image-04970"); } // first mip, all layers { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 8}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // mip 3, layer 0 { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 3, 1, 0, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info); } // mip 3, 8 layers (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 3, 1, 0, 8}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-02725"); } // mip 3, layer 7 (invalid) { const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 3, 1, 7, 1}; VkImageViewCreateInfo img_view_info = volume_img_view_info_template; img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; img_view_info.subresourceRange = range; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-02724"); CreateImageViewTest(*this, &img_view_info, "VUID-VkImageViewCreateInfo-subresourceRange-02725"); } // Checking sparse flags are not set VkImageViewCreateInfo sparse_image_view_ci = volume_img_view_info_template; sparse_image_view_ci.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; // using VK_IMAGE_CREATE_SPARSE_BINDING_BIT if (device_features.sparseBinding) { VkImageObj sparse_image(m_device); image_ci.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_SPARSE_BINDING_BIT; sparse_image.Init(image_ci, 0, false); sparse_image_view_ci.image = sparse_image.handle(); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); } // using VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT if (device_features.sparseResidencyImage3D) { VkImageObj sparse_image(m_device); image_ci.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT; m_errorMonitor->SetUnexpectedError("VUID-VkImageCreateInfo-flags-00987"); sparse_image.Init(image_ci, 0, false); sparse_image_view_ci.image = sparse_image.handle(); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); } // using VK_IMAGE_CREATE_SPARSE_ALIASED_BIT if (device_features.sparseResidencyAliased) { VkImageObj sparse_image(m_device); image_ci.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT; sparse_image.Init(image_ci, 0, false); sparse_image_view_ci.image = sparse_image.handle(); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); sparse_image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01020"); CreateImageViewTest(*this, &sparse_image_view_ci, "VUID-VkImageViewCreateInfo-image-04971"); } } } } TEST_F(VkLayerTest, InvalidImageViewLayerCount) { TEST_DESCRIPTION("Image and ImageView arrayLayers/layerCount parameters not being compatibile"); ASSERT_NO_FATAL_FAILURE(Init()); VkImageCreateInfo image_ci = LvlInitStruct(nullptr); image_ci.flags = 0; image_ci.format = VK_FORMAT_R8G8B8A8_UNORM; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_ci.extent = {128, 1, 1}; image_ci.mipLevels = 1; image_ci.arrayLayers = 1; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_ci.imageType = VK_IMAGE_TYPE_1D; VkImageObj image_1d(m_device); image_1d.init(&image_ci); ASSERT_TRUE(image_1d.initialized()); image_ci.imageType = VK_IMAGE_TYPE_2D; VkImageObj image_2d(m_device); image_2d.init(&image_ci); ASSERT_TRUE(image_2d.initialized()); image_ci.imageType = VK_IMAGE_TYPE_3D; VkImageObj image_3d(m_device); image_3d.init(&image_ci); ASSERT_TRUE(image_3d.initialized()); image_ci.arrayLayers = 2; image_ci.imageType = VK_IMAGE_TYPE_1D; VkImageObj image_1d_array(m_device); image_1d_array.init(&image_ci); ASSERT_TRUE(image_1d_array.initialized()); image_ci.imageType = VK_IMAGE_TYPE_2D; VkImageObj image_2d_array(m_device); image_2d_array.init(&image_ci); ASSERT_TRUE(image_2d_array.initialized()); image_ci.imageType = VK_IMAGE_TYPE_3D; VkImageFormatProperties img_limits; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits)); std::optional image_3d_array; image_ci.arrayLayers = 1; // arrayLayers must be 1 for 3D images if (img_limits.maxArrayLayers >= image_ci.arrayLayers) { image_3d_array.emplace(m_device); image_3d_array->init(&image_ci); ASSERT_TRUE(image_3d_array->initialized()); } // base for each test that never changes VkImageViewCreateInfo image_view_ci = LvlInitStruct(nullptr); image_view_ci.format = VK_FORMAT_R8G8B8A8_UNORM; image_view_ci.subresourceRange.baseMipLevel = 0; image_view_ci.subresourceRange.levelCount = 1; image_view_ci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Sanity checks { image_view_ci.subresourceRange.baseArrayLayer = 0; image_view_ci.subresourceRange.layerCount = 1; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_1D; image_view_ci.image = image_1d_array.image(); CreateImageViewTest(*this, &image_view_ci); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_ci.image = image_2d_array.image(); CreateImageViewTest(*this, &image_view_ci); if (image_3d_array) { image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_3D; image_view_ci.image = image_3d_array->image(); CreateImageViewTest(*this, &image_view_ci); } image_view_ci.subresourceRange.baseArrayLayer = 1; image_view_ci.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_1D; image_view_ci.image = image_1d_array.image(); CreateImageViewTest(*this, &image_view_ci); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_ci.image = image_2d_array.image(); CreateImageViewTest(*this, &image_view_ci); if (image_3d_array) { image_view_ci.subresourceRange.baseArrayLayer = 0; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_3D; image_view_ci.image = image_3d_array->image(); CreateImageViewTest(*this, &image_view_ci); } image_view_ci.subresourceRange.baseArrayLayer = 0; image_view_ci.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_1D; image_view_ci.image = image_1d.image(); CreateImageViewTest(*this, &image_view_ci); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_ci.image = image_2d.image(); CreateImageViewTest(*this, &image_view_ci); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_3D; image_view_ci.image = image_3d.image(); CreateImageViewTest(*this, &image_view_ci); } // layerCount is not 1 as imageView is not an array type { image_view_ci.subresourceRange.baseArrayLayer = 0; image_view_ci.subresourceRange.layerCount = 2; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_1D; image_view_ci.image = image_1d_array.image(); CreateImageViewTest(*this, &image_view_ci, "VUID-VkImageViewCreateInfo-imageViewType-04973"); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_ci.image = image_2d_array.image(); CreateImageViewTest(*this, &image_view_ci, "VUID-VkImageViewCreateInfo-imageViewType-04973"); if (image_3d_array) { image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_3D; image_view_ci.image = image_3d_array->image(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-subresourceRange-01719"); CreateImageViewTest(*this, &image_view_ci, "VUID-VkImageViewCreateInfo-imageViewType-04973"); } } // layerCount is VK_REMAINING_ARRAY_LAYERS but not 1 { image_view_ci.subresourceRange.baseArrayLayer = 0; image_view_ci.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_1D; image_view_ci.image = image_1d_array.image(); CreateImageViewTest(*this, &image_view_ci, "VUID-VkImageViewCreateInfo-imageViewType-04974"); image_view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_ci.image = image_2d_array.image(); CreateImageViewTest(*this, &image_view_ci, "VUID-VkImageViewCreateInfo-imageViewType-04974"); } } TEST_F(VkLayerTest, CreateImageMiscErrors) { TEST_DESCRIPTION("Misc leftover valid usage errors in VkImageCreateInfo struct"); VkPhysicalDeviceFeatures features{}; ASSERT_NO_FATAL_FAILURE(Init(&features)); VkImageCreateInfo tmp_img_ci = LvlInitStruct(); tmp_img_ci.flags = 0; // assumably any is supported tmp_img_ci.imageType = VK_IMAGE_TYPE_2D; // any is supported tmp_img_ci.format = VK_FORMAT_R8G8B8A8_UNORM; // has mandatory support for all usages tmp_img_ci.extent = {64, 64, 1}; // limit is 256 for 3D, or 4096 tmp_img_ci.mipLevels = 1; // any is supported tmp_img_ci.arrayLayers = 1; // limit is 256 tmp_img_ci.samples = VK_SAMPLE_COUNT_1_BIT; // needs to be 1 if TILING_LINEAR // if VK_IMAGE_TILING_LINEAR imageType must be 2D, usage must be TRANSFER, and levels layers samplers all 1 tmp_img_ci.tiling = VK_IMAGE_TILING_OPTIMAL; tmp_img_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; // depends on format tmp_img_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; const VkImageCreateInfo safe_image_ci = tmp_img_ci; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &safe_image_ci)); { VkImageCreateInfo image_ci = safe_image_ci; image_ci.sharingMode = VK_SHARING_MODE_CONCURRENT; image_ci.queueFamilyIndexCount = 2; image_ci.pQueueFamilyIndices = nullptr; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-sharingMode-00941"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.sharingMode = VK_SHARING_MODE_CONCURRENT; image_ci.queueFamilyIndexCount = 1; const uint32_t queue_family = 0; image_ci.pQueueFamilyIndices = &queue_family; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-sharingMode-00942"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.format = VK_FORMAT_UNDEFINED; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-format-00943"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; image_ci.arrayLayers = 6; image_ci.imageType = VK_IMAGE_TYPE_1D; image_ci.extent = {64, 1, 1}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-flags-00949"); image_ci = safe_image_ci; image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; image_ci.imageType = VK_IMAGE_TYPE_3D; image_ci.extent = {4, 4, 4}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-flags-00949"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // always has 4 samples support image_ci.samples = VK_SAMPLE_COUNT_4_BIT; image_ci.imageType = VK_IMAGE_TYPE_3D; image_ci.extent = {4, 4, 4}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02257"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // always has 4 samples support image_ci.samples = VK_SAMPLE_COUNT_4_BIT; image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; image_ci.arrayLayers = 6; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02257"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // always has 4 samples support image_ci.samples = VK_SAMPLE_COUNT_4_BIT; image_ci.tiling = VK_IMAGE_TILING_LINEAR; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02257"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // always has 4 samples support image_ci.samples = VK_SAMPLE_COUNT_4_BIT; image_ci.mipLevels = 2; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02257"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_ci.samples = VK_SAMPLE_COUNT_4_BIT; image_ci.mipLevels = 1; image_ci.tiling = VK_IMAGE_TILING_LINEAR; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02257"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.mipLevels = 2; image_ci.flags = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-flags-02259"); image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.mipLevels = 1; image_ci.flags = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT; image_ci.tiling = VK_IMAGE_TILING_LINEAR; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-flags-02259"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_ci.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00963"); image_ci.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00966"); image_ci.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; image_ci.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-usage-00963"); CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00966"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.flags = VK_IMAGE_CREATE_SPARSE_BINDING_BIT; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-flags-00969"); } // InitialLayout not VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREDEFINED { VkImageCreateInfo image_ci = safe_image_ci; image_ci.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-initialLayout-00993"); } // Storage usage can't be multisample if feature not set { // Feature should not have been set for these tests ASSERT_TRUE(features.shaderStorageImageMultisample == VK_FALSE); VkImageCreateInfo image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_STORAGE_BIT; image_ci.samples = VK_SAMPLE_COUNT_2_BIT; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00968"); } } TEST_F(VkLayerTest, CreateImageMinLimitsViolation) { TEST_DESCRIPTION("Create invalid image with invalid parameters violation minimum limit, such as being zero."); ASSERT_NO_FATAL_FAILURE(Init()); VkImage null_image; // throwaway target for all the vk::CreateImage VkImageCreateInfo tmp_img_ci = LvlInitStruct(); tmp_img_ci.flags = 0; // assumably any is supported tmp_img_ci.imageType = VK_IMAGE_TYPE_2D; // any is supported tmp_img_ci.format = VK_FORMAT_R8G8B8A8_UNORM; // has mandatory support for all usages tmp_img_ci.extent = {1, 1, 1}; // limit is 256 for 3D, or 4096 tmp_img_ci.mipLevels = 1; // any is supported tmp_img_ci.arrayLayers = 1; // limit is 256 tmp_img_ci.samples = VK_SAMPLE_COUNT_1_BIT; // needs to be 1 if TILING_LINEAR // if VK_IMAGE_TILING_LINEAR imageType must be 2D, usage must be TRANSFER, and levels layers samplers all 1 tmp_img_ci.tiling = VK_IMAGE_TILING_OPTIMAL; tmp_img_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; // depends on format tmp_img_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; const VkImageCreateInfo safe_image_ci = tmp_img_ci; enum Dimension { kWidth = 0x1, kHeight = 0x2, kDepth = 0x4 }; for (std::underlying_type::type bad_dimensions = 0x1; bad_dimensions < 0x8; ++bad_dimensions) { VkExtent3D extent = {1, 1, 1}; if (bad_dimensions & kWidth) { extent.width = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-00944"); } if (bad_dimensions & kHeight) { extent.height = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-00945"); } if (bad_dimensions & kDepth) { extent.depth = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-00946"); } VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.imageType = VK_IMAGE_TYPE_3D; // has to be 3D otherwise it might trigger the non-1 error instead bad_image_ci.extent = extent; vk::CreateImage(m_device->device(), &bad_image_ci, NULL, &null_image); m_errorMonitor->VerifyFound(); } { VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.mipLevels = 0; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-mipLevels-00947"); } { VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.arrayLayers = 0; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-arrayLayers-00948"); } { VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; bad_image_ci.arrayLayers = 5; // arrayLayers must be greater than or equal to 6 CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00954"); bad_image_ci.arrayLayers = 6; bad_image_ci.extent = {64, 63, 1}; // extent.width and extent.height must be equal CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00954"); } { VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.imageType = VK_IMAGE_TYPE_1D; bad_image_ci.extent = {64, 2, 1}; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00956"); bad_image_ci.imageType = VK_IMAGE_TYPE_1D; bad_image_ci.extent = {64, 1, 2}; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00956"); bad_image_ci.imageType = VK_IMAGE_TYPE_2D; bad_image_ci.extent = {64, 64, 2}; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00957"); bad_image_ci.imageType = VK_IMAGE_TYPE_2D; bad_image_ci.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; bad_image_ci.arrayLayers = 6; bad_image_ci.extent = {64, 64, 2}; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00957"); } { VkImageCreateInfo bad_image_ci = safe_image_ci; bad_image_ci.imageType = VK_IMAGE_TYPE_3D; bad_image_ci.arrayLayers = 2; CreateImageTest(*this, &bad_image_ci, "VUID-VkImageCreateInfo-imageType-00961"); } } TEST_F(VkLayerTest, CreateImageMaxLimitsViolation) { TEST_DESCRIPTION("Create invalid image with invalid parameters exceeding physical device limits."); // Check for VK_KHR_get_physical_device_properties2 AddOptionalExtensions(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME); AddOptionalExtensions(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); const bool push_fragment_density_support = IsExtensionsEnabled(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME); const bool push_fragment_density_offset_support = IsExtensionsEnabled(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, 0)); VkImageCreateInfo tmp_img_ci = LvlInitStruct(); tmp_img_ci.flags = 0; // assumably any is supported tmp_img_ci.imageType = VK_IMAGE_TYPE_2D; // any is supported tmp_img_ci.format = VK_FORMAT_R8G8B8A8_UNORM; // has mandatory support for all usages tmp_img_ci.extent = {1, 1, 1}; // limit is 256 for 3D, or 4096 tmp_img_ci.mipLevels = 1; // any is supported tmp_img_ci.arrayLayers = 1; // limit is 256 tmp_img_ci.samples = VK_SAMPLE_COUNT_1_BIT; // needs to be 1 if TILING_LINEAR // if VK_IMAGE_TILING_LINEAR imageType must be 2D, usage must be TRANSFER, and levels layers samplers all 1 tmp_img_ci.tiling = VK_IMAGE_TILING_OPTIMAL; tmp_img_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; // depends on format tmp_img_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; const VkImageCreateInfo safe_image_ci = tmp_img_ci; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &safe_image_ci)); const VkPhysicalDeviceLimits &dev_limits = m_device->props.limits; { VkImageCreateInfo image_ci = safe_image_ci; image_ci.extent = {8, 8, 1}; image_ci.mipLevels = 4 + 1; // 4 = log2(8) + 1 CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-mipLevels-00958"); image_ci.extent = {8, 15, 1}; image_ci.mipLevels = 4 + 1; // 4 = floor(log2(15)) + 1 CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-mipLevels-00958"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.tiling = VK_IMAGE_TILING_LINEAR; image_ci.extent = {64, 64, 1}; image_ci.format = FindFormatLinearWithoutMips(gpu(), image_ci); image_ci.mipLevels = 2; if (image_ci.format != VK_FORMAT_UNDEFINED) { CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-mipLevels-02255"); } else { printf("Cannot find a format to test maxMipLevels limit; skipping part of test.\n"); } } { VkImageCreateInfo image_ci = safe_image_ci; VkImageFormatProperties img_limits; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits)); if (img_limits.maxArrayLayers != vvl::kU32Max) { image_ci.arrayLayers = img_limits.maxArrayLayers + 1; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-arrayLayers-02256"); } else { printf("VkImageFormatProperties::maxArrayLayers is already UINT32_MAX; skipping part of test.\n"); } } { VkImageCreateInfo image_ci = safe_image_ci; bool found = FindFormatWithoutSamples(gpu(), image_ci); if (found) { CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-samples-02258"); } else { printf("Could not find a format with some unsupported samples; skipping part of test.\n"); } } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.imageType = VK_IMAGE_TYPE_3D; VkImageFormatProperties img_limits; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits)); image_ci.extent = {img_limits.maxExtent.width + 1, 1, 1}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-extent-02252"); image_ci.extent = {1, img_limits.maxExtent.height + 1, 1}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-extent-02253"); image_ci.extent = {1, 1, img_limits.maxExtent.depth + 1}; CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-extent-02254"); } { VkImageCreateInfo image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // (any attachment bit) VkImageFormatProperties img_limits; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits)); if (dev_limits.maxFramebufferWidth != vvl::kU32Max) { image_ci.extent = {dev_limits.maxFramebufferWidth + 1, 64, 1}; if (dev_limits.maxFramebufferWidth + 1 > img_limits.maxExtent.width) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-02252"); } CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00964"); } else { printf("VkPhysicalDeviceLimits::maxFramebufferWidth is already UINT32_MAX; skipping part of test.\n"); } if (dev_limits.maxFramebufferHeight != vvl::kU32Max) { image_ci.extent = {64, dev_limits.maxFramebufferHeight + 1, 1}; if (dev_limits.maxFramebufferHeight + 1 > img_limits.maxExtent.height) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-02253"); } CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-00965"); } else { printf("VkPhysicalDeviceLimits::maxFramebufferHeight is already UINT32_MAX; skipping part of test.\n"); } } { if (!push_fragment_density_support) { printf("VK_EXT_fragment_density_map Extension not supported, skipping tests\n"); } else { VkImageCreateInfo image_ci = safe_image_ci; image_ci.usage = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT; image_ci.format = VK_FORMAT_R8G8_UNORM; // only mandatory format for fragment density map VkImageFormatProperties img_limits; ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits)); image_ci.extent = {dev_limits.maxFramebufferWidth + 1, 64, 1}; if (dev_limits.maxFramebufferWidth + 1 > img_limits.maxExtent.width) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-02252"); } if (!push_fragment_density_offset_support) { CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06514"); } image_ci.extent = {64, dev_limits.maxFramebufferHeight + 1, 1}; if (dev_limits.maxFramebufferHeight + 1 > img_limits.maxExtent.height) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-extent-02253"); } if (!push_fragment_density_offset_support) { CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06515"); } } } } TEST_F(VkLayerTest, DepthStencilImageViewWithColorAspectBitError) { // Create a single Image descriptor and cause it to first hit an error due // to using a DS format, then cause it to hit error due to COLOR_BIT not // set in aspect // The image format check comes 2nd in validation so we trigger it first, // then when we cause aspect fail next, bad format check will be preempted m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidImageAspect"); ASSERT_NO_FATAL_FAILURE(Init()); auto depth_format = FindSupportedDepthStencilFormat(gpu()); VkImageObj image_bad(m_device); VkImageObj image_good(m_device); // One bad format and one good format for Color attachment const VkFormat tex_format_bad = depth_format; const VkFormat tex_format_good = VK_FORMAT_B8G8R8A8_UNORM; const int32_t tex_width = 32; const int32_t tex_height = 32; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = tex_format_bad; image_create_info.extent.width = tex_width; image_create_info.extent.height = tex_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_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; image_create_info.flags = 0; image_bad.init(&image_create_info); image_create_info.format = tex_format_good; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; image_good.init(&image_create_info); VkImageViewCreateInfo image_view_create_info = LvlInitStruct(); image_view_create_info.image = image_bad.handle(); image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = tex_format_bad; image_view_create_info.subresourceRange.baseArrayLayer = 0; image_view_create_info.subresourceRange.baseMipLevel = 0; image_view_create_info.subresourceRange.layerCount = 1; image_view_create_info.subresourceRange.levelCount = 1; image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; VkImageView view; vk::CreateImageView(m_device->device(), &image_view_create_info, NULL, &view); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, CornerSampledImageNV) { TEST_DESCRIPTION("Test VK_NV_corner_sampled_image."); AddRequiredExtensions(VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto corner_sampled_image_features = LvlInitStruct(); GetPhysicalDeviceFeatures2(corner_sampled_image_features); if (corner_sampled_image_features.cornerSampledImage != VK_TRUE) { GTEST_SKIP() << "cornerSampledImage feature not supported"; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &corner_sampled_image_features)); VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_1D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent.width = 2; 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.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_create_info.flags = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV; // image type must be 2D or 3D CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02050"); // cube/depth not supported image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.extent.height = 2; image_create_info.format = VK_FORMAT_D24_UNORM_S8_UINT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02051"); image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; // 2D width/height must be > 1 image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.extent.height = 1; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02052"); // 3D width/height/depth must be > 1 image_create_info.imageType = VK_IMAGE_TYPE_3D; image_create_info.extent.height = 2; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02053"); image_create_info.imageType = VK_IMAGE_TYPE_2D; // Valid # of mip levels image_create_info.extent = {7, 7, 1}; image_create_info.mipLevels = 3; // 3 = ceil(log2(7)) CreateImageTest(*this, &image_create_info); image_create_info.extent = {8, 8, 1}; image_create_info.mipLevels = 3; // 3 = ceil(log2(8)) CreateImageTest(*this, &image_create_info); image_create_info.extent = {9, 9, 1}; image_create_info.mipLevels = 3; // 4 = ceil(log2(9)) CreateImageTest(*this, &image_create_info); // Invalid # of mip levels image_create_info.extent = {8, 8, 1}; image_create_info.mipLevels = 4; // 3 = ceil(log2(8)) CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-mipLevels-00958"); } TEST_F(VkLayerTest, ImageStencilCreate) { TEST_DESCRIPTION("Verify ImageStencil create info."); AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); AddRequiredExtensions(VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); VkPhysicalDeviceFeatures device_features = {}; ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); device_features.shaderStorageImageMultisample = VK_FALSE; // Force multisampled storage images off if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState(&device_features)); PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceImageFormatProperties2KHR"); ASSERT_TRUE(vkGetPhysicalDeviceImageFormatProperties2KHR != nullptr); VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.flags = 0; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent = {64, 64, 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; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = nullptr; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VkImageStencilUsageCreateInfoEXT image_stencil_create_info = LvlInitStruct(); image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_STORAGE_BIT; image_create_info.pNext = &image_stencil_create_info; VkPhysicalDeviceImageFormatInfo2 image_format_info2 = LvlInitStruct(&image_stencil_create_info); image_format_info2.format = image_create_info.format; image_format_info2.type = image_create_info.imageType; image_format_info2.tiling = image_create_info.tiling; image_format_info2.usage = image_create_info.usage; image_format_info2.flags = image_create_info.flags; VkImageFormatProperties2 image_format_properties2 = LvlInitStruct(); image_format_properties2.imageFormatProperties = {}; // when including VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, must not include bits other than // VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539"); vkGetPhysicalDeviceImageFormatProperties2KHR(m_device->phy().handle(), &image_format_info2, &image_format_properties2); m_errorMonitor->VerifyFound(); // test vkCreateImage as well for this case CreateImageTest(*this, &image_create_info, "VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539"); const VkPhysicalDeviceLimits &dev_limits = m_device->props.limits; if (dev_limits.maxFramebufferWidth != vvl::kU32Max) { // depth-stencil format image with VkImageStencilUsageCreateInfo with // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set cannot have image width exceeding device maximum image_create_info.format = VK_FORMAT_D32_SFLOAT_S8_UINT; image_create_info.extent = {dev_limits.maxFramebufferWidth + 1, 64, 1}; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-Format-02536"); } else { printf("VkPhysicalDeviceLimits::maxFramebufferWidth is already UINT32_MAX; skipping part of test.\n"); } if (dev_limits.maxFramebufferHeight != vvl::kU32Max) { // depth-stencil format image with VkImageStencilUsageCreateInfo with // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set cannot have image height exceeding device maximum image_create_info.format = VK_FORMAT_D32_SFLOAT_S8_UINT; image_create_info.extent = {64, dev_limits.maxFramebufferHeight + 1, 1}; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02537"); } else { printf("VkPhysicalDeviceLimits::maxFramebufferHeight is already UINT32_MAX; skipping part of test.\n"); } // depth-stencil format image with VkImageStencilUsageCreateInfo with // VK_IMAGE_USAGE_STORAGE_BIT and the multisampled storage images feature // is not enabled, image samples must be VK_SAMPLE_COUNT_1_BIT image_create_info.format = VK_FORMAT_D32_SFLOAT_S8_UINT; image_create_info.extent = {64, 64, 1}; image_create_info.samples = VK_SAMPLE_COUNT_2_BIT; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_STORAGE_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02538"); image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; // depth-stencil format image with VkImageStencilUsageCreateInfo, usage includes // VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, so VkImageStencilUsageCreateInfo::stencilUsage // must also include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT image_create_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02795"); // depth-stencil format image with VkImageStencilUsageCreateInfo, usage does not include // VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, so VkImageStencilUsageCreateInfo::stencilUsage // must also not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02796"); // depth-stencil format image with VkImageStencilUsageCreateInfo, usage includes // VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, so VkImageStencilUsageCreateInfo::stencilUsage // must also include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT image_create_info.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_STORAGE_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02797"); // depth-stencil format image with VkImageStencilUsageCreateInfo, usage does not include // VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, so VkImageStencilUsageCreateInfo::stencilUsage // must also not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_stencil_create_info.stencilUsage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-format-02798"); } TEST_F(VkLayerTest, FragmentDensityMapEnabled) { TEST_DESCRIPTION("Validation must check several conditions that apply only when Fragment Density Maps are used."); // VK_EXT_fragment_density_map2 requires VK_EXT_fragment_density_map AddRequiredExtensions(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME); AddOptionalExtensions(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); const bool fdm2Supported = IsExtensionsEnabled(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } VkPhysicalDeviceFragmentDensityMapFeaturesEXT density_map_features = LvlInitStruct(); VkPhysicalDeviceFragmentDensityMap2FeaturesEXT density_map2_features = LvlInitStruct(&density_map_features); VkPhysicalDeviceFeatures2KHR features2 = GetPhysicalDeviceFeatures2(density_map2_features); if (density_map_features.fragmentDensityMapDynamic == VK_FALSE) { GTEST_SKIP() << "fragmentDensityMapDynamic not supported"; } PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceProperties2KHR"); ASSERT_TRUE(vkGetPhysicalDeviceProperties2KHR != nullptr); VkPhysicalDeviceFragmentDensityMap2PropertiesEXT density_map2_properties = LvlInitStruct(); VkPhysicalDeviceProperties2KHR properties2 = LvlInitStruct(&density_map2_properties); vkGetPhysicalDeviceProperties2KHR(gpu(), &properties2); features2 = LvlInitStruct(&density_map2_features); ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); // Test sampler parameters VkSamplerCreateInfo sampler_info_ref = SafeSaneSamplerCreateInfo(); sampler_info_ref.maxLod = 0.0; sampler_info_ref.flags |= VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT; VkSamplerCreateInfo sampler_info = sampler_info_ref; // min max filters must match sampler_info.minFilter = VK_FILTER_LINEAR; sampler_info.magFilter = VK_FILTER_NEAREST; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02574"); sampler_info.minFilter = sampler_info_ref.minFilter; sampler_info.magFilter = sampler_info_ref.magFilter; // mipmapMode must be SAMPLER_MIPMAP_MODE_NEAREST sampler_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02575"); sampler_info.mipmapMode = sampler_info_ref.mipmapMode; // minLod and maxLod must be 0.0 sampler_info.minLod = 1.0; sampler_info.maxLod = 1.0; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02576"); sampler_info.minLod = sampler_info_ref.minLod; sampler_info.maxLod = sampler_info_ref.maxLod; // addressMode must be CLAMP_TO_EDGE or CLAMP_TO_BORDER sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02577"); sampler_info.addressModeU = sampler_info_ref.addressModeU; sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02577"); sampler_info.addressModeV = sampler_info_ref.addressModeV; // some features cannot be enabled for subsampled samplers if (features2.features.samplerAnisotropy == VK_TRUE) { sampler_info.anisotropyEnable = VK_TRUE; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02578"); sampler_info.anisotropyEnable = sampler_info_ref.anisotropyEnable; sampler_info.anisotropyEnable = VK_FALSE; } sampler_info.compareEnable = VK_TRUE; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02579"); sampler_info.compareEnable = sampler_info_ref.compareEnable; sampler_info.unnormalizedCoordinates = VK_TRUE; CreateSamplerTest(*this, &sampler_info, "VUID-VkSamplerCreateInfo-flags-02580"); sampler_info.unnormalizedCoordinates = sampler_info_ref.unnormalizedCoordinates; // Test image parameters VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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_FRAGMENT_DENSITY_MAP_BIT_EXT; image_create_info.flags = 0; // only VK_IMAGE_TYPE_2D is supported image_create_info.imageType = VK_IMAGE_TYPE_1D; image_create_info.extent.height = 1; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02557"); // only VK_SAMPLE_COUNT_1_BIT is supported image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-samples-02558"); // tiling must be VK_IMAGE_TILING_OPTIMAL image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_create_info.flags = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT; image_create_info.tiling = VK_IMAGE_TILING_LINEAR; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02565"); // only 2D image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_create_info.imageType = VK_IMAGE_TYPE_1D; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02566"); // no cube maps image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.extent.height = 64; image_create_info.arrayLayers = 6; image_create_info.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02567"); // mipLevels must be 1 image_create_info.flags = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT; image_create_info.arrayLayers = 1; image_create_info.mipLevels = 2; CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-flags-02568"); // Test image view parameters // create a valid density map image image_create_info.flags = 0; image_create_info.mipLevels = 1; image_create_info.usage = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT; VkImageObj densityImage(m_device); densityImage.init(&image_create_info); ASSERT_TRUE(densityImage.initialized()); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = densityImage.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // density maps can't be sparse (or protected) if (features2.features.sparseResidencyImage2D) { image_create_info.flags = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT; image_create_info.usage = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT; VkImageObj image(m_device); image.init_no_mem(*m_device, image_create_info); ASSERT_TRUE(image.initialized()); ivci.image = image.handle(); CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-flags-04116"); } if (fdm2Supported) { if (!density_map2_features.fragmentDensityMapDeferred) { ivci.flags = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT; ivci.image = densityImage.handle(); CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-flags-03567"); } else { ivci.flags = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT; ivci.flags |= VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT; ivci.image = densityImage.handle(); CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-flags-03568"); } if (density_map2_properties.maxSubsampledArrayLayers < properties2.properties.limits.maxImageArrayLayers) { image_create_info.flags = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.arrayLayers = density_map2_properties.maxSubsampledArrayLayers + 1; VkImageObj image(m_device); image.init(&image_create_info); ASSERT_TRUE(image.initialized()); ivci.image = image.handle(); ivci.flags = 0; ivci.subresourceRange.layerCount = density_map2_properties.maxSubsampledArrayLayers + 1; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-imageViewType-04973"); CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-03569"); } } } TEST_F(VkLayerTest, FragmentDensityMapDisabled) { TEST_DESCRIPTION("Checks for when the fragment density map features are not enabled."); // VK_EXT_fragment_density_map2 requires VK_EXT_fragment_density_map AddRequiredExtensions(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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; image_create_info.flags = 0; VkImageObj image2D(m_device); image2D.init(&image_create_info); ASSERT_TRUE(image2D.initialized()); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image2D.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Flags must not be set if the feature is not enabled ivci.flags = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-flags-02572"); } TEST_F(VkLayerTest, AstcDecodeMode) { TEST_DESCRIPTION("Tests for VUs for VK_EXT_astc_decode_mode"); AddRequiredExtensions(VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto astc_decode_features = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(astc_decode_features); if (!features2.features.textureCompressionASTC_LDR) { GTEST_SKIP() << "textureCompressionASTC_LDR feature not supported"; } // Disable feature astc_decode_features.decodeModeSharedExponent = VK_FALSE; ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); const VkFormat rgba_format = VK_FORMAT_R8G8B8A8_UNORM; const VkFormat ldr_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK; VkImageObj image(m_device); image.Init(128, 128, 1, rgba_format, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkImageObj astc_image(m_device); astc_image.Init(128, 128, 1, ldr_format, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(astc_image.initialized()); VkImageViewASTCDecodeModeEXT astc_decode_mode = LvlInitStruct(); astc_decode_mode.decodeMode = VK_FORMAT_R16G16B16A16_SFLOAT; VkImageView image_view; VkImageViewCreateInfo image_view_create_info = LvlInitStruct(&astc_decode_mode); image_view_create_info.image = image.handle(); image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = rgba_format; image_view_create_info.subresourceRange.layerCount = 1; image_view_create_info.subresourceRange.baseMipLevel = 0; image_view_create_info.subresourceRange.levelCount = 1; image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // image view format is not ASTC m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewASTCDecodeModeEXT-format-04084"); vk::CreateImageView(m_device->device(), &image_view_create_info, nullptr, &image_view); m_errorMonitor->VerifyFound(); // Non-valid decodeMode image_view_create_info.image = astc_image.handle(); image_view_create_info.format = ldr_format; astc_decode_mode.decodeMode = ldr_format; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02230"); vk::CreateImageView(m_device->device(), &image_view_create_info, nullptr, &image_view); m_errorMonitor->VerifyFound(); // decodeModeSharedExponent not enabled astc_decode_mode.decodeMode = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02231"); vk::CreateImageView(m_device->device(), &image_view_create_info, nullptr, &image_view); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, CreateImageViewIncompatibleFormat) { TEST_DESCRIPTION("Tests for VUID-VkImageViewCreateInfo-image-01761"); // original issue https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/2203 AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); VkPhysicalDeviceFeatures device_features = {}; ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); const bool ycbcr_support = IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); const bool maintenance2_support = IsExtensionsEnabled(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } const char *error_vuid; if ((!maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01018"; } else if ((maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01759"; } else if ((!maintenance2_support) && (ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01760"; } else { // both enabled error_vuid = "VUID-VkImageViewCreateInfo-image-01761"; } ASSERT_NO_FATAL_FAILURE(InitState(&device_features)); VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, 0, VK_IMAGE_TYPE_2D, VK_FORMAT_R8_UINT, {128, 128, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; imageInfo.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; VkImageObj mutImage(m_device); mutImage.init(&imageInfo); ASSERT_TRUE(mutImage.initialized()); VkImageViewCreateInfo imgViewInfo = LvlInitStruct(); imgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imgViewInfo.subresourceRange.layerCount = 1; imgViewInfo.subresourceRange.baseMipLevel = 0; imgViewInfo.subresourceRange.levelCount = 1; imgViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imgViewInfo.image = mutImage.handle(); // The Image's format is non-planar and incompatible with the ImageView's format, which should trigger // VUID-VkImageViewCreateInfo-image-01761 imgViewInfo.format = VK_FORMAT_B8G8R8A8_UNORM; CreateImageViewTest(*this, &imgViewInfo, error_vuid); // With a identical format, there should be no error imgViewInfo.format = imageInfo.format; CreateImageViewTest(*this, &imgViewInfo, {}); VkImageObj mut_compat_image(m_device); mut_compat_image.init(&imageInfo); ASSERT_TRUE(mut_compat_image.initialized()); imgViewInfo.image = mut_compat_image.handle(); imgViewInfo.format = VK_FORMAT_R8_SINT; // different, but size compatible CreateImageViewTest(*this, &imgViewInfo, {}); } TEST_F(VkLayerTest, CreateImageViewIncompatibleDepthFormat) { TEST_DESCRIPTION("Tests for VUID-VkImageViewCreateInfo-image-01761 with depth format"); AddRequiredExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); VkPhysicalDeviceFeatures device_features = {}; ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); const bool ycbcr_support = IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); const bool maintenance2_support = IsExtensionsEnabled(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } const char *error_vuid; if ((!maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01018"; } else if ((maintenance2_support) && (!ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01759"; } else if ((!maintenance2_support) && (ycbcr_support)) { error_vuid = "VUID-VkImageViewCreateInfo-image-01760"; } else { // both enabled error_vuid = "VUID-VkImageViewCreateInfo-image-01761"; } ASSERT_NO_FATAL_FAILURE(InitState(&device_features)); const VkFormat depthOnlyFormat = FindSupportedDepthOnlyFormat(gpu()); const VkFormat depthStencilFormat = FindSupportedDepthStencilFormat(gpu()); VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, nullptr, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, depthStencilFormat, {128, 128, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImageObj mutImage(m_device); mutImage.init(&imageInfo); ASSERT_TRUE(mutImage.initialized()); VkImageViewCreateInfo imgViewInfo = LvlInitStruct(); imgViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imgViewInfo.subresourceRange.layerCount = 1; imgViewInfo.subresourceRange.baseMipLevel = 0; imgViewInfo.subresourceRange.levelCount = 1; imgViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; imgViewInfo.image = mutImage.handle(); // "Each depth/stencil format is only compatible with itself." imgViewInfo.format = depthOnlyFormat; CreateImageViewTest(*this, &imgViewInfo, error_vuid); } TEST_F(VkLayerTest, CreateImageViewMissingYcbcrConversion) { TEST_DESCRIPTION("Do not use VkSamplerYcbcrConversionInfo when required for an image view."); // Use 1.1 to get VK_KHR_sampler_ycbcr_conversion easier SetTargetApiVersion(VK_API_VERSION_1_2); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required"; } auto features11 = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(features11); if (features11.samplerYcbcrConversion != VK_TRUE) { printf("samplerYcbcrConversion not supported, skipping test\n"); return; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); VkImageObj image(m_device); image.Init(128, 128, 1, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkImageViewCreateInfo view_info = LvlInitStruct(); view_info.flags = 0; view_info.image = image.handle(); view_info.viewType = VK_IMAGE_VIEW_TYPE_2D; view_info.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; view_info.subresourceRange.layerCount = 1; view_info.subresourceRange.baseMipLevel = 0; view_info.subresourceRange.levelCount = 1; view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; CreateImageViewTest(*this, &view_info, "VUID-VkImageViewCreateInfo-format-06415"); } TEST_F(VkLayerTest, InvalidShadingRateUsage) { TEST_DESCRIPTION("Specify invalid usage of the fragment shading rate image view usage."); AddRequiredExtensions(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_MULTIVIEW_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto fsr_features = LvlInitStruct(); GetPhysicalDeviceFeatures2(fsr_features); if (fsr_features.attachmentFragmentShadingRate != VK_TRUE) { GTEST_SKIP() << "requires attachmentFragmentShadingRate feature"; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &fsr_features)); const VkFormat format = FindFormatWithoutFeatures(gpu(), VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR); if (format == VK_FORMAT_UNDEFINED) { GTEST_SKIP() << "No format found without shading rate attachment support"; } VkImageFormatProperties imageFormatProperties; if (vk::GetPhysicalDeviceImageFormatProperties(gpu(), format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, 0, &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED) { GTEST_SKIP() << "Format not supported"; } VkImageObj image(m_device); // Initialize image with transfer source usage image.Init(128, 128, 1, format, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_TILING_OPTIMAL, 0); ASSERT_TRUE(image.initialized()); VkImageView imageview; VkImageViewCreateInfo createinfo = LvlInitStruct(); createinfo.image = image.handle(); createinfo.viewType = VK_IMAGE_VIEW_TYPE_2D; createinfo.format = format; createinfo.subresourceRange.layerCount = 1; createinfo.subresourceRange.baseMipLevel = 0; createinfo.subresourceRange.levelCount = 1; if (FormatIsColor(format)) { createinfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; } else if (FormatHasDepth(format)) { createinfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; } else if (FormatHasStencil(format)) { createinfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; } // Create a view with the fragment shading rate attachment usage, but that doesn't support it m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-usage-04550"); vk::CreateImageView(m_device->device(), &createinfo, NULL, &imageview); m_errorMonitor->VerifyFound(); VkPhysicalDeviceFragmentShadingRatePropertiesKHR fsrProperties = LvlInitStruct(); VkPhysicalDeviceProperties2 properties = LvlInitStruct(&fsrProperties); GetPhysicalDeviceProperties2(properties); if (!fsrProperties.layeredShadingRateAttachments) { if (IsPlatform(kMockICD)) { GTEST_SKIP() << "Test not supported by MockICD, doesn't correctly advertise format support for fragment shading " "rate attachments"; } else { VkImageObj image2(m_device); image2.Init(VkImageObj::ImageCreateInfo2D(128, 128, 1, 2, VK_FORMAT_R8_UINT, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_TILING_OPTIMAL)); ASSERT_TRUE(image2.initialized()); createinfo.image = image2.handle(); createinfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; createinfo.format = VK_FORMAT_R8_UINT; createinfo.subresourceRange.layerCount = 2; createinfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-usage-04551"); vk::CreateImageView(m_device->device(), &createinfo, NULL, &imageview); m_errorMonitor->VerifyFound(); } } } TEST_F(VkLayerTest, InvalidImageFormatList) { TEST_DESCRIPTION("Tests for VK_KHR_image_format_list"); AddRequiredExtensions(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); // Use sampled formats that will always be supported // Last format is not compatible with the rest const VkFormat formats[4] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8_UNORM}; VkImageFormatListCreateInfo formatList = LvlInitStruct(nullptr); formatList.viewFormatCount = 4; formatList.pViewFormats = formats; VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &formatList, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, {128, 128, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; VkImage badImage = VK_NULL_HANDLE; VkImageObj mutableImage(m_device); VkImageObj mutableImageZero(m_device); VkImageObj normalImage(m_device); // Not all 4 formats are compatible m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-pNext-06722"); vk::CreateImage(device(), &imageInfo, nullptr, &badImage); m_errorMonitor->VerifyFound(); // Should work with only first 3 in array formatList.viewFormatCount = 3; mutableImage.init(&imageInfo); ASSERT_TRUE(mutableImage.initialized()); // Make sure no error if 0 format formatList.viewFormatCount = 0; formatList.pViewFormats = &formats[3]; // non-compatible format mutableImageZero.init(&imageInfo); ASSERT_TRUE(mutableImageZero.initialized()); // reset formatList.viewFormatCount = 3; formatList.pViewFormats = formats; // Can't use 2 or higher formats if no mutable flag m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-flags-04738"); imageInfo.flags = 0; vk::CreateImage(device(), &imageInfo, nullptr, &badImage); m_errorMonitor->VerifyFound(); // Make sure no error if 1 format formatList.viewFormatCount = 1; normalImage.init(&imageInfo); ASSERT_TRUE(normalImage.initialized()); VkImageViewCreateInfo imageViewInfo = LvlInitStruct(nullptr); imageViewInfo.flags = 0; imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imageViewInfo.subresourceRange.layerCount = 1; imageViewInfo.subresourceRange.baseMipLevel = 0; imageViewInfo.subresourceRange.levelCount = 1; imageViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imageViewInfo.image = mutableImage.handle(); // Not in format list imageViewInfo.format = VK_FORMAT_R8_SNORM; m_errorMonitor->SetUnexpectedError("VUID-VkImageViewCreateInfo-image-01018"); CreateImageViewTest(*this, &imageViewInfo, "VUID-VkImageViewCreateInfo-pNext-01585"); imageViewInfo.format = VK_FORMAT_R8G8B8A8_SNORM; CreateImageViewTest(*this, &imageViewInfo, {}); // If viewFormatCount is zero should not hit VUID 01585 imageViewInfo.image = mutableImageZero.handle(); CreateImageViewTest(*this, &imageViewInfo, {}); } TEST_F(VkLayerTest, InvalidImageFormatListSizeCompatible) { TEST_DESCRIPTION("Tests for VK_KHR_image_format_list with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"); AddRequiredExtensions(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_MAINTENANCE2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); if (!ImageFormatAndFeaturesSupported(gpu(), VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { GTEST_SKIP() << "Required formats/features not supported"; } const VkFormat formats[2] = {VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32_UINT}; VkImageFormatListCreateInfo formatList = LvlInitStruct(nullptr); formatList.viewFormatCount = 1; formatList.pViewFormats = formats; VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &formatList, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, {128, 128, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; // The first image in the list should be size-compatible (128-bit) VkImageObj good_image(m_device); good_image.init(&imageInfo); // The second image in the list should NOT be size-compatible (64-bit) formatList.viewFormatCount = 2; VkImage badImage = VK_NULL_HANDLE; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCreateInfo-pNext-06722"); vk::CreateImage(device(), &imageInfo, nullptr, &badImage); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, InvalidImageSplitInstanceBindRegionCount) { TEST_DESCRIPTION("Bind image memory with VkBindImageMemoryDeviceGroupInfo but invalid flags"); AddRequiredExtensions(VK_KHR_DEVICE_GROUP_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); // Check that all extensions and their dependencies were enabled successfully if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); PFN_vkBindImageMemory2KHR vkBindImageMemory2Function = nullptr; if (DeviceValidationVersion() >= VK_API_VERSION_1_1) { vkBindImageMemory2Function = vk::BindImageMemory2; } else { vkBindImageMemory2Function = (PFN_vkBindImageMemory2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkBindImageMemory2KHR"); } VkImageCreateInfo image_create_info = LvlInitStruct(nullptr); image_create_info.flags = 0; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED; image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); image.init_no_mem(*m_device, image_create_info); vk_testing::DeviceMemory image_mem; VkMemoryRequirements mem_reqs; vk::GetImageMemoryRequirements(m_device->device(), image.handle(), &mem_reqs); VkMemoryAllocateInfo mem_alloc = LvlInitStruct(nullptr); mem_alloc.allocationSize = mem_reqs.size; for (int i = 0; i < 32; i++) { if (mem_reqs.memoryTypeBits & (1 << i)) { mem_alloc.memoryTypeIndex = i; break; } } image_mem.init(*m_device, mem_alloc); std::array deviceIndices = {{0, 0}}; VkRect2D splitInstanceBindregion = {{0, 0}, {16, 16}}; VkBindImageMemoryDeviceGroupInfo bind_devicegroup_info = LvlInitStruct(); bind_devicegroup_info.deviceIndexCount = 2; bind_devicegroup_info.pDeviceIndices = deviceIndices.data(); bind_devicegroup_info.splitInstanceBindRegionCount = 1; bind_devicegroup_info.pSplitInstanceBindRegions = &splitInstanceBindregion; VkBindImageMemoryInfo bindInfo = LvlInitStruct(); bindInfo.pNext = &bind_devicegroup_info; bindInfo.image = image.handle(); bindInfo.memory = image_mem.handle(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBindImageMemoryInfo-pNext-01627"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634"); vkBindImageMemory2Function(device(), 1, &bindInfo); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, InvalidImageSplitInstanceBindRegionCountWithDeviceGroup) { TEST_DESCRIPTION("Bind image memory with VkBindImageMemoryDeviceGroupInfo but invalid splitInstanceBindRegionCount"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_KHR_DEVICE_GROUP_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "Vulkan >= 1.1 required"; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } uint32_t physical_device_group_count = 0; vk::EnumeratePhysicalDeviceGroups(instance(), &physical_device_group_count, nullptr); if (physical_device_group_count == 0) { GTEST_SKIP() << "physical_device_group_count is 0"; } std::vector physical_device_group(physical_device_group_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); vk::EnumeratePhysicalDeviceGroups(instance(), &physical_device_group_count, physical_device_group.data()); auto create_device_pnext = LvlInitStruct(); create_device_pnext.physicalDeviceCount = 0; create_device_pnext.pPhysicalDevices = nullptr; for (const auto &dg : physical_device_group) { if (dg.physicalDeviceCount > 1) { create_device_pnext.physicalDeviceCount = dg.physicalDeviceCount; create_device_pnext.pPhysicalDevices = dg.physicalDevices; break; } } if (create_device_pnext.pPhysicalDevices) { ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &create_device_pnext)); } else { GTEST_SKIP() << "Test requires a physical device group with more than 1 device to use " "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"; } PFN_vkBindImageMemory2KHR vkBindImageMemory2Function = nullptr; if (DeviceValidationVersion() >= VK_API_VERSION_1_1) { vkBindImageMemory2Function = vk::BindImageMemory2; } else { vkBindImageMemory2Function = (PFN_vkBindImageMemory2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkBindImageMemory2KHR"); } VkImageCreateInfo image_create_info = LvlInitStruct(nullptr); image_create_info.flags = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED; image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); image.init_no_mem(*m_device, image_create_info); VkDeviceMemory image_mem; VkMemoryRequirements mem_reqs; vk::GetImageMemoryRequirements(m_device->device(), image.handle(), &mem_reqs); VkMemoryAllocateInfo mem_alloc = LvlInitStruct(nullptr); mem_alloc.allocationSize = mem_reqs.size; for (int i = 0; i < 32; i++) { if (mem_reqs.memoryTypeBits & (1 << i)) { mem_alloc.memoryTypeIndex = i; break; } } vk::AllocateMemory(device(), &mem_alloc, NULL, &image_mem); VkRect2D splitInstanceBindregion = {{0, 0}, {16, 16}}; VkBindImageMemoryDeviceGroupInfo bind_devicegroup_info = LvlInitStruct(); bind_devicegroup_info.splitInstanceBindRegionCount = 2; bind_devicegroup_info.pSplitInstanceBindRegions = &splitInstanceBindregion; VkBindImageMemoryInfo bindInfo = LvlInitStruct(); bindInfo.pNext = &bind_devicegroup_info; bindInfo.image = image.handle(); bindInfo.memory = image_mem; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636"); vkBindImageMemory2Function(device(), 1, &bindInfo); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, BlockTexelViewInvalidLevelOrLayerCount) { TEST_DESCRIPTION( "Attempts to create an Image View with an image using VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, but levelCount and " "layerCount are not 1."); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); auto image_create_info = LvlInitStruct(); image_create_info.flags = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_BC1_RGBA_UNORM_BLOCK; image_create_info.extent.width = 32; image_create_info.extent.height = 32; image_create_info.extent.depth = 1; image_create_info.mipLevels = 4; image_create_info.arrayLayers = 2; image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); VkFormatProperties image_fmt; vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_create_info.format, &image_fmt); if (!image.IsCompatible(image_create_info.usage, image_fmt.optimalTilingFeatures)) { GTEST_SKIP() << "Image usage and format not compatible on device"; } image.Init(image_create_info, 0); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; ivci.format = VK_FORMAT_R16G16B16A16_UNORM; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Test for error message ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.levelCount = 4; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-07072"); // Test for error message ivci.subresourceRange.layerCount = 2; ivci.subresourceRange.levelCount = 1; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-07072"); } TEST_F(VkLayerTest, InvalidBindIMageMemoryDeviceGroupInfo) { TEST_DESCRIPTION("Checks for invalid BindIMageMemoryDeviceGroupInfo."); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_KHR_DEVICE_GROUP_EXTENSION_NAME); AddRequiredExtensions(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "Vulkan >= 1.1 required"; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } uint32_t physical_device_group_count = 0; vk::EnumeratePhysicalDeviceGroups(instance(), &physical_device_group_count, nullptr); if (physical_device_group_count == 0) { GTEST_SKIP() << "physical_device_group_count is 0, skipping test"; } std::vector physical_device_group(physical_device_group_count, {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}); vk::EnumeratePhysicalDeviceGroups(instance(), &physical_device_group_count, physical_device_group.data()); auto create_device_pnext = LvlInitStruct(); create_device_pnext.physicalDeviceCount = 0; create_device_pnext.pPhysicalDevices = nullptr; for (const auto &dg : physical_device_group) { if (dg.physicalDeviceCount > 1) { create_device_pnext.physicalDeviceCount = dg.physicalDeviceCount; create_device_pnext.pPhysicalDevices = dg.physicalDevices; break; } } if (create_device_pnext.pPhysicalDevices) { ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &create_device_pnext)); } else { GTEST_SKIP() << "Test requires a physical device group with more than 1 device to use " "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT."; } PFN_vkBindImageMemory2KHR vkBindImageMemory2Function = (PFN_vkBindImageMemory2KHR)vk::GetDeviceProcAddr(m_device->handle(), "vkBindImageMemory2KHR"); VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.flags = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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; VkImageObj image(m_device); image.init_no_mem(*m_device, image_create_info); VkMemoryRequirements mem_reqs; vk::GetImageMemoryRequirements(m_device->device(), image.handle(), &mem_reqs); VkMemoryAllocateInfo mem_alloc = LvlInitStruct(); mem_alloc.allocationSize = mem_reqs.size; mem_alloc.memoryTypeIndex = mem_reqs.memoryTypeBits; bool pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0); if (!pass) { GTEST_SKIP() << "Failed to set memory type."; } vk_testing::DeviceMemory memory; memory.init(*m_device, mem_alloc); uint32_t deviceIndex = 0; VkRect2D region = {}; region.offset.x = 0; region.offset.y = 0; region.extent.width = image.width(); region.extent.height = image.height(); VkBindImageMemoryDeviceGroupInfo bimdgi = LvlInitStruct(); bimdgi.deviceIndexCount = 1; bimdgi.pDeviceIndices = &deviceIndex; bimdgi.splitInstanceBindRegionCount = 1; bimdgi.pSplitInstanceBindRegions = ®ion; VkBindImageMemoryInfo bind_info = LvlInitStruct(&bimdgi); bind_info.image = image.handle(); bind_info.memory = memory.handle(); bind_info.memoryOffset = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633"); vkBindImageMemory2Function(m_device->device(), 1, &bind_info); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, BlockTexelViewInvalidType) { TEST_DESCRIPTION( "Create Image with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT and non-compressed format and ImageView with view type " "VK_IMAGE_VIEW_TYPE_3D."); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); auto image_create_info = LvlInitStruct(); image_create_info.flags = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; image_create_info.imageType = VK_IMAGE_TYPE_3D; image_create_info.format = VK_FORMAT_BC1_RGBA_SRGB_BLOCK; 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_OPTIMAL; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); VkFormatProperties image_fmt; vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_create_info.format, &image_fmt); if (!image.IsCompatible(image_create_info.usage, image_fmt.optimalTilingFeatures)) { GTEST_SKIP() << "Image usage and format not compatible on device"; } image.Init(image_create_info, 0); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_3D; ivci.format = VK_FORMAT_R16G16B16A16_UNORM; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.levelCount = 1; // Test for no error message, as VUID was removed CreateImageViewTest(*this, &ivci); } TEST_F(VkLayerTest, BlockTexelViewInvalidFormat) { TEST_DESCRIPTION("Create Image with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT with non compatible formats."); AddRequiredExtensions(VK_KHR_MAINTENANCE_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); auto image_create_info = LvlInitStruct(); image_create_info.flags = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_BC1_RGBA_SRGB_BLOCK; // 64-bit block size 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_OPTIMAL; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); VkFormatProperties image_fmt; vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_create_info.format, &image_fmt); if (!image.IsCompatible(image_create_info.usage, image_fmt.optimalTilingFeatures)) { GTEST_SKIP() << "Image usage and format not compatible on device"; } image.Init(image_create_info, 0); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.levelCount = 1; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; // 32-bit block size CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01583"); ivci.format = VK_FORMAT_BC1_RGB_SRGB_BLOCK; // 64-bit block size, but not same format class CreateImageViewTest(*this, &ivci, "VUID-VkImageViewCreateInfo-image-01583"); ivci.format = VK_FORMAT_BC1_RGBA_UNORM_BLOCK; // 64-bit block size, and same format class CreateImageViewTest(*this, &ivci); } TEST_F(VkLayerTest, InvalidImageSubresourceRangeAspectMask) { TEST_DESCRIPTION("Test creating Image with invalid VkImageSubresourceRange aspectMask."); SetTargetApiVersion(VK_API_VERSION_1_2); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required"; } auto features11 = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(features11); if (features11.samplerYcbcrConversion != VK_TRUE) { printf("samplerYcbcrConversion not supported, skipping test\n"); return; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); VkFormat mp_format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; if (!ImageFormatAndFeaturesSupported(gpu(), mp_format, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT)) { GTEST_SKIP() << "Required formats/features not supported"; } VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = mp_format; 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_OPTIMAL; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.queueFamilyIndexCount = 0; image_create_info.pQueueFamilyIndices = NULL; image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageObj image(m_device); image.init(&image_create_info); ASSERT_TRUE(image.initialized()); VkSamplerYcbcrConversionCreateInfo ycbcr_create_info = LvlInitStruct(); ycbcr_create_info.format = mp_format; ycbcr_create_info.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; ycbcr_create_info.ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL; ycbcr_create_info.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}; ycbcr_create_info.xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN; ycbcr_create_info.yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN; ycbcr_create_info.chromaFilter = VK_FILTER_NEAREST; ycbcr_create_info.forceExplicitReconstruction = false; VkSamplerYcbcrConversion conversion; vk::CreateSamplerYcbcrConversion(m_device->device(), &ycbcr_create_info, nullptr, &conversion); VkSamplerYcbcrConversionInfo ycbcr_info = LvlInitStruct(); ycbcr_info.conversion = conversion; VkImageViewCreateInfo ivci = LvlInitStruct(&ycbcr_info); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = mp_format; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT; CreateImageViewTest(*this, &ivci, "VUID-VkImageSubresourceRange-aspectMask-01670"); vk::DestroySamplerYcbcrConversion(m_device->device(), conversion, nullptr); } TEST_F(VkLayerTest, InvalidCreateImageQueueFamilies) { TEST_DESCRIPTION("Checks for invalid queue families in ImageCreateInfo."); AddOptionalExtensions(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); const bool get_physical_device_properties2 = IsExtensionsEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); uint32_t queue_families[2] = {0, 0}; VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; 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.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_create_info.queueFamilyIndexCount = 2; image_create_info.pQueueFamilyIndices = queue_families; image_create_info.sharingMode = VK_SHARING_MODE_CONCURRENT; const char *vuid = (get_physical_device_properties2) ? "VUID-VkImageCreateInfo-sharingMode-01420" : "VUID-VkImageCreateInfo-sharingMode-01392"; CreateImageTest(*this, &image_create_info, vuid); uint32_t queue_node_count; vk::GetPhysicalDeviceQueueFamilyProperties(gpu(), &queue_node_count, NULL); queue_families[1] = queue_node_count; CreateImageTest(*this, &image_create_info, vuid); } TEST_F(VkLayerTest, ImageFormatInfoDrmFormatModifier) { TEST_DESCRIPTION("Validate VkPhysicalDeviceImageFormatInfo2."); AddRequiredExtensions(VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); auto vkGetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)vk::GetInstanceProcAddr( instance(), "vkGetPhysicalDeviceImageFormatProperties2KHR"); ASSERT_TRUE(vkGetPhysicalDeviceImageFormatProperties2KHR != nullptr); VkPhysicalDeviceImageDrmFormatModifierInfoEXT image_drm_format_modifier = LvlInitStruct(); VkPhysicalDeviceImageFormatInfo2 image_format_info = LvlInitStruct(&image_drm_format_modifier); image_format_info.format = VK_FORMAT_R8G8B8A8_UNORM; image_format_info.type = VK_IMAGE_TYPE_2D; image_format_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_format_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_format_info.flags = 0; VkImageFormatProperties2 image_format_properties = LvlInitStruct(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02249"); vkGetPhysicalDeviceImageFormatProperties2KHR(gpu(), &image_format_info, &image_format_properties); m_errorMonitor->VerifyFound(); image_format_info.pNext = nullptr; image_format_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02249"); vkGetPhysicalDeviceImageFormatProperties2KHR(gpu(), &image_format_info, &image_format_properties); m_errorMonitor->VerifyFound(); image_format_info.pNext = &image_drm_format_modifier; image_drm_format_modifier.sharingMode = VK_SHARING_MODE_CONCURRENT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02315"); vkGetPhysicalDeviceImageFormatProperties2KHR(gpu(), &image_format_info, &image_format_properties); m_errorMonitor->VerifyFound(); image_drm_format_modifier.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VkImageFormatListCreateInfo format_list = LvlInitStruct(&image_drm_format_modifier); format_list.viewFormatCount = 0; // Invalid image_format_info.pNext = &format_list; image_format_info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02313"); vkGetPhysicalDeviceImageFormatProperties2KHR(gpu(), &image_format_info, &image_format_properties); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, InvalidMultiSampleImageView) { TEST_DESCRIPTION("Begin conditional rendering when it is already active."); AddRequiredExtensions(VK_KHR_MAINTENANCE_1_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } ASSERT_NO_FATAL_FAILURE(InitState()); const VkPhysicalDeviceLimits &dev_limits = m_device->props.limits; if ((dev_limits.sampledImageColorSampleCounts & VK_SAMPLE_COUNT_2_BIT) == 0) { GTEST_SKIP() << "Required VkSampleCountFlagBits are not supported; skipping"; } VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8B8A8_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; image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; VkImageFormatProperties image_format_properties; vk::GetPhysicalDeviceImageFormatProperties(gpu(), image_create_info.format, image_create_info.imageType, image_create_info.tiling, image_create_info.usage, image_create_info.flags, &image_format_properties); if (image_format_properties.sampleCounts < 2) { GTEST_SKIP() << "Required VkSampleCountFlagBits for image format are not supported; skipping"; } VkImageObj image(m_device); image.init(&image_create_info); VkImageViewCreateInfo dsvci = LvlInitStruct(); dsvci.image = image.handle(); dsvci.viewType = VK_IMAGE_VIEW_TYPE_3D; dsvci.format = image_create_info.format; dsvci.subresourceRange.layerCount = 1; dsvci.subresourceRange.baseMipLevel = 0; dsvci.subresourceRange.levelCount = 1; dsvci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-subResourceRange-01021"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-04972"); vk_testing::ImageView imageView(*m_device, dsvci); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, Image2DViewOf3D) { TEST_DESCRIPTION("Checks for invalid use of 2D views of 3D images"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required"; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto image_2D_view_of_3D_features = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(image_2D_view_of_3D_features); if (!image_2D_view_of_3D_features.image2DViewOf3D) { GTEST_SKIP() << "Test requires unsupported image2DViewOf3D feature"; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); OneOffDescriptorSet descriptor_set(m_device, {{0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_ALL, nullptr}}); VkImageCreateInfo image_ci = LvlInitStruct(); image_ci.imageType = VK_IMAGE_TYPE_3D; image_ci.format = VK_FORMAT_B8G8R8A8_UNORM; image_ci.extent = {64, 64, 4}; image_ci.mipLevels = 1; image_ci.arrayLayers = 1; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT; image_ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_ci.flags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; VkImageObj image_3d(m_device); image_3d.init(&image_ci); ASSERT_TRUE(image_3d.initialized()); VkImageViewCreateInfo view_ci = LvlInitStruct(); view_ci.image = image_3d.handle(); view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; view_ci.format = VK_FORMAT_B8G8R8A8_UNORM; view_ci.subresourceRange.layerCount = 1; view_ci.subresourceRange.baseMipLevel = 0; view_ci.subresourceRange.levelCount = 1; view_ci.subresourceRange.baseArrayLayer = 0; view_ci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vk_testing::ImageView view_2d_array; view_2d_array.init(*m_device, view_ci); descriptor_set.WriteDescriptorImageInfo(0, view_2d_array.handle(), VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorImageInfo-imageView-06712"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); descriptor_set.descriptor_writes.clear(); vk_testing::ImageView view_2d; view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; view_2d.init(*m_device, view_ci); descriptor_set.WriteDescriptorImageInfo(0, view_2d.handle(), VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorImageInfo-imageView-07796"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); descriptor_set.descriptor_writes.clear(); image_ci.flags = 0; VkImageObj image_3d_no_flag(m_device); image_3d_no_flag.init(&image_ci); VkImageView view; view_ci.image = image_3d_no_flag.handle(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-06728"); vk::CreateImageView(m_device->device(), &view_ci, nullptr, &view); m_errorMonitor->VerifyFound(); const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 1, 1}; view_ci.subresourceRange = range; view_ci.image = image_3d_no_flag.handle(); view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-06723"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-image-06724"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewCreateInfo-subresourceRange-06725"); vk::CreateImageView(m_device->device(), &view_ci, nullptr, &view); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, Image2DViewOf3DFeature) { TEST_DESCRIPTION("Checks for image image_2d_view_of_3d features"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required"; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto image_2D_view_of_3D_features = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(image_2D_view_of_3D_features); image_2D_view_of_3D_features.image2DViewOf3D = VK_FALSE; image_2D_view_of_3D_features.sampler2DViewOf3D = VK_FALSE; ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); OneOffDescriptorSet descriptor_set(m_device, {{0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_ALL, nullptr}, {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_ALL, nullptr}}); VkImageCreateInfo image_ci = LvlInitStruct(); image_ci.imageType = VK_IMAGE_TYPE_3D; image_ci.format = VK_FORMAT_B8G8R8A8_UNORM; image_ci.extent = {64, 64, 4}; image_ci.mipLevels = 1; image_ci.arrayLayers = 1; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT; image_ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; image_ci.flags = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT; VkImageObj image_3d(m_device); image_3d.init(&image_ci); ASSERT_TRUE(image_3d.initialized()); VkImageViewCreateInfo view_ci = LvlInitStruct(); view_ci.image = image_3d.handle(); view_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; view_ci.format = VK_FORMAT_B8G8R8A8_UNORM; view_ci.subresourceRange.layerCount = 1; view_ci.subresourceRange.baseMipLevel = 0; view_ci.subresourceRange.levelCount = 1; view_ci.subresourceRange.baseArrayLayer = 0; view_ci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vk_testing::ImageView view_2d_array; view_2d_array.init(*m_device, view_ci); descriptor_set.WriteDescriptorImageInfo(0, view_2d_array.handle(), VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorImageInfo-descriptorType-06714"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); descriptor_set.descriptor_writes.clear(); descriptor_set.WriteDescriptorImageInfo(1, view_2d_array.handle(), VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_IMAGE_LAYOUT_GENERAL); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkDescriptorImageInfo-descriptorType-06713"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, ImageViewMinLod) { TEST_DESCRIPTION("Checks for image view minimum level of detail."); AddRequiredExtensions(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto image_view_min_lod_features = LvlInitStruct(); auto features2 = GetPhysicalDeviceFeatures2(image_view_min_lod_features); if (image_view_min_lod_features.minLod == VK_FALSE) { GTEST_SKIP() << "Test requires unsupported minLod feature"; } ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); VkImageCreateInfo image_create_info = LvlInitStruct(); image_create_info.imageType = VK_IMAGE_TYPE_2D; image_create_info.format = VK_FORMAT_R8G8_UNORM; image_create_info.extent.width = 64; image_create_info.extent.height = 64; image_create_info.extent.depth = 1; image_create_info.mipLevels = 4; 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_INPUT_ATTACHMENT_BIT; image_create_info.flags = 0; VkImageObj image2D(m_device); image2D.init(&image_create_info); ASSERT_TRUE(image2D.initialized()); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image2D.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 4; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; auto ivml = LvlInitStruct(); ivml.minLod = 4.0; ivci.pNext = &ivml; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06456"); VkImageView image_view = {}; ivml.minLod = 1.0; VkResult res = vk::CreateImageView(m_device->device(), &ivci, nullptr, &image_view); ASSERT_TRUE(res == VK_SUCCESS); OneOffDescriptorSet descriptor_set(m_device, { {0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}, }); descriptor_set.WriteDescriptorImageInfo(0, image_view, VK_NULL_HANDLE, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-06450"); descriptor_set.UpdateDescriptorSets(); m_errorMonitor->VerifyFound(); vk::DestroyImageView(m_device->device(), image_view, NULL); } TEST_F(VkLayerTest, ImageViewMinLodFeature) { TEST_DESCRIPTION("Checks for image view minimum level of detail feature enabled."); ASSERT_NO_FATAL_FAILURE(Init()); VkImageObj image(m_device); // Initialize image with transfer source usage image.Init(128, 128, 2, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); VkImageViewCreateInfo ivci = LvlInitStruct(); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; ivci.format = VK_FORMAT_R8G8B8A8_UNORM; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 2; ivci.subresourceRange.baseArrayLayer = 0; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; auto ivml = LvlInitStruct(); ivml.minLod = 1.0; ivci.pNext = &ivml; CreateImageViewTest(*this, &ivci, "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06455"); } TEST_F(VkLayerTest, CreateColorImageWithDepthAspect) { TEST_DESCRIPTION("Test creating an image with color format but depth aspect."); ASSERT_NO_FATAL_FAILURE(Init()); auto format = FindSupportedDepthStencilFormat(gpu()); VkImageObj color_image(m_device); color_image.Init(64, 64, 1, format, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL); VkImageViewCreateInfo civ_ci = LvlInitStruct(); civ_ci.image = color_image.handle(); civ_ci.viewType = VK_IMAGE_VIEW_TYPE_2D; civ_ci.format = format; civ_ci.subresourceRange.layerCount = 1; civ_ci.subresourceRange.baseMipLevel = 0; civ_ci.subresourceRange.levelCount = 1; civ_ci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vk_testing::ImageView color_image_view; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidImageAspect"); color_image_view.init(*m_device, civ_ci); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, TestImageCopyMissingUsage) { TEST_DESCRIPTION("Test copying from src image without VK_IMAGE_USAGE_TRANSFER_SRC_BIT."); SetTargetApiVersion(VK_API_VERSION_1_2); AddRequiredExtensions(VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(Init()); if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required."; } auto format = FindSupportedDepthStencilFormat(gpu()); auto stencil_usage_ci = LvlInitStruct(); stencil_usage_ci.stencilUsage = VK_IMAGE_USAGE_SAMPLED_BIT; auto image_ci = LvlInitStruct(); image_ci.imageType = VK_IMAGE_TYPE_2D; image_ci.format = format; image_ci.extent.width = 32; image_ci.extent.height = 32; image_ci.extent.depth = 1; image_ci.mipLevels = 1; image_ci.arrayLayers = 1; image_ci.samples = VK_SAMPLE_COUNT_1_BIT; image_ci.tiling = VK_IMAGE_TILING_OPTIMAL; image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT; VkImageObj sampled_image(m_device); sampled_image.Init(image_ci); image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj transfer_image(m_device); transfer_image.Init(image_ci); image_ci.pNext = &stencil_usage_ci; image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT; VkImageObj separate_stencil_sampled_image(m_device); separate_stencil_sampled_image.Init(image_ci); image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; stencil_usage_ci.stencilUsage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageObj separate_stencil_transfer_image(m_device); separate_stencil_transfer_image.Init(image_ci); VkImageCopy region; region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; region.srcSubresource.mipLevel = 0; region.srcSubresource.baseArrayLayer = 0; region.srcSubresource.layerCount = 1; region.srcOffset.x = 0; region.srcOffset.y = 0; region.srcOffset.z = 0; region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; region.dstSubresource.mipLevel = 0; region.dstSubresource.baseArrayLayer = 0; region.dstSubresource.layerCount = 1; region.dstOffset.x = 0; region.dstOffset.y = 0; region.dstOffset.z = 0; region.extent.width = 32; region.extent.height = 32; region.extent.depth = 1; m_commandBuffer->begin(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspect-06662"); vk::CmdCopyImage(m_commandBuffer->handle(), sampled_image.handle(), VK_IMAGE_LAYOUT_GENERAL, transfer_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspect-06663"); vk::CmdCopyImage(m_commandBuffer->handle(), transfer_image.handle(), VK_IMAGE_LAYOUT_GENERAL, sampled_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspect-06664"); vk::CmdCopyImage(m_commandBuffer->handle(), separate_stencil_sampled_image.handle(), VK_IMAGE_LAYOUT_GENERAL, separate_stencil_transfer_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-aspect-06665"); vk::CmdCopyImage(m_commandBuffer->handle(), separate_stencil_transfer_image.handle(), VK_IMAGE_LAYOUT_GENERAL, separate_stencil_sampled_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); m_errorMonitor->VerifyFound(); m_commandBuffer->end(); } TEST_F(VkLayerTest, GetImageSubresourceLayoutInvalidDrmPlane) { TEST_DESCRIPTION("Try to get image subresource layout for drm image plane 3 when it only has 2"); // Try to enable 1.2 since all required extensions were promoted SetTargetApiVersion(VK_API_VERSION_1_2); AddRequiredExtensions(VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); // By this point we already know if all required device extensions are supported if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported().c_str() << " extensions not supported."; } ASSERT_NO_FATAL_FAILURE(InitState()); VkFormat format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; VkDrmFormatModifierPropertiesListEXT modifiers_list = LvlInitStruct(); VkFormatProperties2 format_properties = LvlInitStruct(&modifiers_list); vk::GetPhysicalDeviceFormatProperties2(m_device->phy().handle(), format, &format_properties); if (modifiers_list.drmFormatModifierCount == 0) { GTEST_SKIP() << "No drm format modifier found for image format VK_FORMAT_G8_B8R8_2PLANE_420_UNORM."; } std::vector modifiers_properties(modifiers_list.drmFormatModifierCount); modifiers_list.pDrmFormatModifierProperties = modifiers_properties.data(); vk::GetPhysicalDeviceFormatProperties2(m_device->phy().handle(), format, &format_properties); size_t modifier_index = 0u; for (; modifier_index < modifiers_properties.size(); ++modifier_index) { if (modifiers_properties[modifier_index].drmFormatModifierPlaneCount < 3) { break; } } if (modifier_index >= modifiers_properties.size()) { GTEST_SKIP() << "No drm modifier found with less than 3 planes needed for testing."; } uint64_t chosen_drm_modifier = modifiers_properties[modifier_index].drmFormatModifier; VkImageDrmFormatModifierListCreateInfoEXT list_create_info = LvlInitStruct(); list_create_info.drmFormatModifierCount = 1u; list_create_info.pDrmFormatModifiers = &chosen_drm_modifier; VkImageCreateInfo create_info = LvlInitStruct(&list_create_info); create_info.imageType = VK_IMAGE_TYPE_2D; create_info.format = format; create_info.extent.width = 64; create_info.extent.height = 64; create_info.extent.depth = 1; create_info.mipLevels = 1; create_info.arrayLayers = 1; create_info.samples = VK_SAMPLE_COUNT_1_BIT; create_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; VkImageObj image{m_device}; image.init_no_mem(*m_device, create_info); if (image.initialized() == false) { GTEST_SKIP() << "Failed to create image."; } // Try to get layout for plane 3 when we only have 2 VkImageSubresource subresource{}; subresource.aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT; VkSubresourceLayout layout{}; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout-tiling-02271"); vk::GetImageSubresourceLayout(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, InvalidImageCompressionControl) { TEST_DESCRIPTION("Checks image compression controls with invalid parameters."); SetTargetApiVersion(VK_API_VERSION_1_2); AddRequiredExtensions(VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME); AddOptionalExtensions(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); const bool multi_plane_extensions = IsExtensionsEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required, skipping test."; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } auto image_compression_control = LvlInitStruct(); GetPhysicalDeviceFeatures2(image_compression_control); if (!image_compression_control.imageCompressionControl) { GTEST_SKIP() << "Test requires (unsupported) imageCompressionControl, skipping."; } auto vkGetImageSubresourceLayout2EXT = reinterpret_cast( vk::GetInstanceProcAddr(instance(), "vkGetImageSubresourceLayout2EXT")); ASSERT_TRUE(vkGetImageSubresourceLayout2EXT != nullptr); // A bit set flag bit ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &image_compression_control)); { auto compression_control = LvlInitStruct(); // specify the desired compression settings compression_control.flags = VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT | VK_IMAGE_COMPRESSION_DISABLED_EXT; auto image_create_info = VkImageObj::ImageCreateInfo2D(128, 128, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_LINEAR); image_create_info.pNext = &compression_control; CreateImageTest(*this, &image_create_info, "VUID-VkImageCompressionControlEXT-flags-06747"); } // Explicit Fixed Rate { auto compression_control = LvlInitStruct(); // specify the desired compression settings compression_control.flags = VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT; compression_control.pFixedRateFlags = nullptr; auto image_create_info = VkImageObj::ImageCreateInfo2D(128, 128, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_LINEAR); image_create_info.pNext = &compression_control; CreateImageTest(*this, &image_create_info, "VUID-VkImageCompressionControlEXT-flags-06748"); } // Image creation lambda const auto create_compressed_image = [&](VkFormat format, VkImageTiling imageTiling, VkImageObj &image) -> bool { auto compression_control = LvlInitStruct(); // specify the desired compression settings compression_control.flags = VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT; auto image_create_info = VkImageObj::ImageCreateInfo2D(128, 128, 1, 1, format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, imageTiling); image_create_info.pNext = &compression_control; bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), image_create_info, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT); if (supported) { image.init(&image_create_info); } return supported; }; // Exceed MipmapLevel { VkImageObj image(m_device); if (create_compressed_image(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-mipLevel-01716"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 1, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // Exceed ArrayLayers { VkImageObj image(m_device); if (create_compressed_image(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-arrayLayer-01717"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // Color format aspect { VkImageObj image(m_device); if (create_compressed_image(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-04461"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_PLANE_0_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // Depth format, Stencil aspect { const VkFormat depth_format = FindSupportedDepthOnlyFormat(gpu()); VkImageObj image(m_device); if (create_compressed_image(depth_format, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-04462"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // Stencil format, Depth aspect const VkFormat stencil_format = FindSupportedStencilOnlyFormat(gpu()); if (stencil_format != VK_FORMAT_UNDEFINED) { VkImageObj image(m_device); if (create_compressed_image(stencil_format, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-04463"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // AspectMask should be a bitset { const VkFormat depth_stencil_format = FindSupportedDepthStencilFormat(gpu()); VkImageObj image(m_device); if (create_compressed_image(depth_stencil_format, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-aspectMask-00997"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // Depth/Stencil format aspect { VkImageObj image(m_device); if (create_compressed_image(VK_FORMAT_R8G8B8A8_SNORM, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-04461"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-04464"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_DEPTH_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // 2 plane format const VkFormat two_plane_format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR; if (multi_plane_extensions) { VkImageObj image(m_device); if (create_compressed_image(two_plane_format, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-01581"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_PLANE_2_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } // 3 plane format const VkFormat three_plane_format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR; if (multi_plane_extensions) { VkImageObj image(m_device); if (create_compressed_image(three_plane_format, VK_IMAGE_TILING_LINEAR, image)) { m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkGetImageSubresourceLayout2EXT-format-01582"); VkImageSubresource2EXT subresource = LvlInitStruct(); subresource.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0}; VkImageCompressionPropertiesEXT compressionProperties = LvlInitStruct(); VkSubresourceLayout2EXT layout = LvlInitStruct(&compressionProperties); vkGetImageSubresourceLayout2EXT(m_device->handle(), image.handle(), &subresource, &layout); m_errorMonitor->VerifyFound(); } } } TEST_F(VkLayerTest, TransitionNonSparseImageLayoutWithoutBoundMemory) { TEST_DESCRIPTION("Try to change layout of non sparse image with no memory bound."); ASSERT_NO_FATAL_FAILURE(Init()); VkImageCreateInfo info = vk_testing::Image::create_info(); info.format = VK_FORMAT_B8G8R8A8_UNORM; info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; VkImageObj image{m_device}; image.init_no_mem(*m_device, info); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageMemoryBarrier-image-01932"); image.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, AttachmentFeedbackLoopLayoutFeature) { SetTargetApiVersion(VK_API_VERSION_1_2); AddRequiredExtensions(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME); AddRequiredExtensions(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_2) { GTEST_SKIP() << "At least Vulkan version 1.2 is required"; } if (!CheckSynchronization2SupportAndInitState(this)) { GTEST_SKIP() << "Synchronization2 not supported"; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } VkImageCreateInfo info = vk_testing::Image::create_info(); info.format = VK_FORMAT_B8G8R8A8_UNORM; info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT; VkImageObj image{m_device}; image.init(&info); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageMemoryBarrier-attachmentFeedbackLoopLayout-07313"); image.SetLayout(VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT); m_errorMonitor->VerifyFound(); m_commandBuffer->begin(); auto img_barrier = LvlInitStruct(); img_barrier.image = image.handle(); img_barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; img_barrier.srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; img_barrier.dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; img_barrier.newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; auto dep_info = LvlInitStruct(); dep_info.imageMemoryBarrierCount = 1; dep_info.pImageMemoryBarriers = &img_barrier; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageMemoryBarrier2-attachmentFeedbackLoopLayout-07313"); m_commandBuffer->PipelineBarrier2KHR(&dep_info); m_errorMonitor->VerifyFound(); VkAttachmentReference attach = {}; attach.layout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; VkSubpassDescription subpass = {}; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &attach; VkRenderPassCreateInfo rpci = LvlInitStruct(); rpci.subpassCount = 1; rpci.pSubpasses = &subpass; rpci.attachmentCount = 1; VkAttachmentDescription attach_desc = {}; attach_desc.format = VK_FORMAT_B8G8R8A8_UNORM; attach_desc.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attach_desc.samples = VK_SAMPLE_COUNT_1_BIT; attach_desc.finalLayout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; rpci.pAttachments = &attach_desc; VkRenderPass rp; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentDescription-attachmentFeedbackLoopLayout-07310"); vk::CreateRenderPass(m_device->device(), &rpci, NULL, &rp); m_errorMonitor->VerifyFound(); attach_desc.finalLayout = VK_IMAGE_LAYOUT_GENERAL; attach_desc.initialLayout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentDescription-attachmentFeedbackLoopLayout-07309"); vk::CreateRenderPass(m_device->device(), &rpci, NULL, &rp); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentReference-attachmentFeedbackLoopLayout-07311"); attach_desc.initialLayout = VK_IMAGE_LAYOUT_GENERAL; vk::CreateRenderPass(m_device->device(), &rpci, NULL, &rp); m_errorMonitor->VerifyFound(); VkAttachmentReference2 attach2 = LvlInitStruct(); attach2.layout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; VkSubpassDescription2 subpass2 = LvlInitStruct(); subpass2.colorAttachmentCount = 1; subpass2.pColorAttachments = &attach2; VkRenderPassCreateInfo2 rpci2 = LvlInitStruct(); rpci2.subpassCount = 1; rpci2.pSubpasses = &subpass2; rpci2.attachmentCount = 1; VkAttachmentDescription2 attach_desc2 = LvlInitStruct(); attach_desc2.format = VK_FORMAT_B8G8R8A8_UNORM; // Set loadOp to CLEAR attach_desc2.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attach_desc2.samples = VK_SAMPLE_COUNT_1_BIT; attach_desc2.finalLayout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; rpci2.pAttachments = &attach_desc2; VkRenderPass rp2; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentDescription2-attachmentFeedbackLoopLayout-07310"); vk::CreateRenderPass2(m_device->device(), &rpci2, NULL, &rp2); m_errorMonitor->VerifyFound(); attach_desc2.finalLayout = VK_IMAGE_LAYOUT_GENERAL; attach_desc2.initialLayout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentDescription2-attachmentFeedbackLoopLayout-07309"); vk::CreateRenderPass2(m_device->device(), &rpci2, NULL, &rp); m_errorMonitor->VerifyFound(); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkAttachmentReference2-attachmentFeedbackLoopLayout-07311"); attach_desc2.initialLayout = VK_IMAGE_LAYOUT_GENERAL; vk::CreateRenderPass2(m_device->device(), &rpci2, NULL, &rp); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, SlicedCreateInfoDeviceFeature) { TEST_DESCRIPTION("Test SlicedCreateInfo feature support validation"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required, skipping test."; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } // NOTE: We are NOT enabling the VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::imageSlicedViewOf3D feature! InitState(); VkImageObj image(m_device); auto ci = LvlInitStruct(); 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_COLOR_ATTACHMENT_BIT; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image.init(&ci); ASSERT_TRUE(image.initialized()); auto sliced_info = LvlInitStruct(); sliced_info.sliceCount = VK_REMAINING_3D_SLICES_EXT; sliced_info.sliceOffset = 0; auto ivci = LvlInitStruct(&sliced_info); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_3D; ivci.format = ci.format; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.baseMipLevel = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-None-07871"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, SlicedCreateInfoInvalidImageType) { TEST_DESCRIPTION("Test SlicedCreateInfo ImageType validation"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required, skipping test."; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } { auto slice_feature = LvlInitStruct(); GetPhysicalDeviceFeatures2(slice_feature); if (slice_feature.imageSlicedViewOf3D == VK_FALSE) { GTEST_SKIP() << "Test requires (unsupported) imageSlicedViewOf3D"; } InitState(nullptr, &slice_feature); } VkImageObj image(m_device); auto ci = LvlInitStruct(); ci.imageType = VK_IMAGE_TYPE_2D; // imageType should be VK_IMAGE_TYPE_3D ci.format = VK_FORMAT_R8G8B8A8_UNORM; 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_COLOR_ATTACHMENT_BIT; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image.init(&ci); ASSERT_TRUE(image.initialized()); auto sliced_info = LvlInitStruct(); sliced_info.sliceCount = VK_REMAINING_3D_SLICES_EXT; sliced_info.sliceOffset = 0; auto ivci = LvlInitStruct(&sliced_info); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_2D; // viewType should be VK_IMAGE_VIEW_TYPE_3D ivci.format = ci.format; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.levelCount = 1; ivci.subresourceRange.baseMipLevel = 0; m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-image-07869"); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-viewType-07909"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } TEST_F(VkLayerTest, SlicedCreateInfoInvalidMipLevel) { TEST_DESCRIPTION("When using VkImageViewSlicedCreateInfoEXT the image view must reference exactly 1 mip level"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required, skipping test."; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } { auto slice_feature = LvlInitStruct(); GetPhysicalDeviceFeatures2(slice_feature); if (slice_feature.imageSlicedViewOf3D == VK_FALSE) { GTEST_SKIP() << "Test requires (unsupported) imageSlicedViewOf3D"; } InitState(nullptr, &slice_feature); } VkImageObj image(m_device); auto ci = LvlInitStruct(); 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_COLOR_ATTACHMENT_BIT; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image.init(&ci); ASSERT_TRUE(image.initialized()); auto sliced_info = LvlInitStruct(); sliced_info.sliceCount = VK_REMAINING_3D_SLICES_EXT; sliced_info.sliceOffset = 0; auto ivci = LvlInitStruct(&sliced_info); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_3D; ivci.format = ci.format; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.layerCount = 1; auto get_effective_mip_levels = [&]() -> uint32_t { return ResolveRemainingLevels(ci, ivci.subresourceRange); }; { ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 4; ASSERT_TRUE(get_effective_mip_levels() == 4); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-None-07870"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { ivci.subresourceRange.baseMipLevel = 0; ivci.subresourceRange.levelCount = 2; ASSERT_TRUE(get_effective_mip_levels() == 2); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-None-07870"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { ivci.subresourceRange.baseMipLevel = 1; ivci.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; ASSERT_TRUE(get_effective_mip_levels() == 5); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-None-07870"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { ivci.subresourceRange.baseMipLevel = 3; ivci.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; ASSERT_TRUE(get_effective_mip_levels() == 3); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-None-07870"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } } TEST_F(VkLayerTest, SlicedCreateInfoInvalidUsage) { TEST_DESCRIPTION("Test invalid sliceCount/sliceOffset of VkImageViewSlicedCreateInfoEXT"); SetTargetApiVersion(VK_API_VERSION_1_1); AddRequiredExtensions(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME); ASSERT_NO_FATAL_FAILURE(InitFramework()); if (DeviceValidationVersion() < VK_API_VERSION_1_1) { GTEST_SKIP() << "At least Vulkan version 1.1 is required, skipping test."; } if (!AreRequiredExtensionsEnabled()) { GTEST_SKIP() << RequiredExtensionsNotSupported() << " not supported"; } { auto slice_feature = LvlInitStruct(); GetPhysicalDeviceFeatures2(slice_feature); if (slice_feature.imageSlicedViewOf3D == VK_FALSE) { GTEST_SKIP() << "Test requires (unsupported) imageSlicedViewOf3D"; } InitState(nullptr, &slice_feature); } VkImageObj image(m_device); auto ci = LvlInitStruct(); 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_COLOR_ATTACHMENT_BIT; ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; image.init(&ci); ASSERT_TRUE(image.initialized()); auto sliced_info = LvlInitStruct(); auto ivci = LvlInitStruct(&sliced_info); ivci.image = image.handle(); ivci.viewType = VK_IMAGE_VIEW_TYPE_3D; ivci.format = ci.format; ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; ivci.subresourceRange.layerCount = 1; ivci.subresourceRange.levelCount = 1; auto get_effective_depth = [&]() -> uint32_t { return GetEffectiveExtent(ci, ivci.subresourceRange).depth; }; { sliced_info.sliceCount = VK_REMAINING_3D_SLICES_EXT; sliced_info.sliceOffset = 9; ivci.subresourceRange.baseMipLevel = 0; ASSERT_TRUE(get_effective_depth() == 8); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-sliceOffset-07867"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { sliced_info.sliceCount = 0; sliced_info.sliceOffset = 0; ivci.subresourceRange.baseMipLevel = 0; ASSERT_TRUE(get_effective_depth() == 8); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-sliceCount-07868"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { sliced_info.sliceCount = 8; sliced_info.sliceOffset = 1; ivci.subresourceRange.baseMipLevel = 0; ASSERT_TRUE(get_effective_depth() == 8); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-sliceCount-07868"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { sliced_info.sliceCount = 4; sliced_info.sliceOffset = 1; ivci.subresourceRange.baseMipLevel = 1; ASSERT_TRUE(get_effective_depth() == 4); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-sliceCount-07868"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } { sliced_info.sliceCount = 2; sliced_info.sliceOffset = 1; ivci.subresourceRange.baseMipLevel = 2; ASSERT_TRUE(get_effective_depth() == 2); m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageViewSlicedCreateInfoEXT-sliceCount-07868"); vk_testing::ImageView image_view(*m_device, ivci); m_errorMonitor->VerifyFound(); } }