| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2020 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file vktSynchronizationNoneStageTests.cpp |
| * \brief Tests for VK_PIPELINE_STAGE_NONE{_2}_KHR that iterate over each writable layout |
| and over each readable layout. Data to tested image is writen using method |
| appropriate for the writable layout and read via readable layout appropriate method. |
| Betwean read and write operation there are bariers that use none stage. |
| Implemented tests are also testing generalized layouts (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, |
| VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR) and access flags (MEMORY_ACCESS_READ|WRITE_BIT) to |
| test contextual synchronization introduced with VK_KHR_synchronization2 extension. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktSynchronizationNoneStageTests.hpp" |
| #include "vktSynchronizationOperation.hpp" |
| #include "vktSynchronizationUtil.hpp" |
| #include "vktTestCase.hpp" |
| |
| #include "vkBuilderUtil.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkObjUtil.hpp" |
| |
| #include "tcuImageCompare.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuStringTemplate.hpp" |
| |
| #include "deUniquePtr.hpp" |
| |
| #include <vector> |
| |
| namespace vkt |
| { |
| namespace synchronization |
| { |
| |
| using namespace vk; |
| using namespace de; |
| using namespace tcu; |
| |
| namespace |
| { |
| |
| static const deUint32 IMAGE_ASPECT_DEPTH_STENCIL = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; |
| static const deUint32 IMAGE_ASPECT_ALL = 0u; |
| |
| struct TestParams |
| { |
| SynchronizationType type; |
| bool useGenericAccessFlags; |
| VkImageLayout writeLayout; |
| VkImageAspectFlags writeAspect; |
| VkImageLayout readLayout; |
| VkImageAspectFlags readAspect; |
| }; |
| |
| // Helper class representing image |
| class ImageWrapper |
| { |
| public: |
| |
| ImageWrapper () = default; |
| void create (Context& context, SimpleAllocator& alloc, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage); |
| |
| public: |
| Move<VkImage> handle; |
| MovePtr<Allocation> memory; |
| }; |
| |
| void ImageWrapper::create(Context& context, SimpleAllocator& alloc, VkFormat format, VkExtent3D extent, VkImageUsageFlags usage) |
| { |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice& device = context.getDevice(); |
| const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); |
| const VkImageCreateInfo imageParams |
| { |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType |
| DE_NULL, // pNext |
| 0u, // flags |
| VK_IMAGE_TYPE_2D, // imageType |
| format, // format |
| extent, // extent |
| 1u, // mipLevels |
| 1u, // arraySize |
| VK_SAMPLE_COUNT_1_BIT, // samples |
| VK_IMAGE_TILING_OPTIMAL, // tiling |
| usage, // usage |
| VK_SHARING_MODE_EXCLUSIVE, // sharingMode |
| 1u, // queueFamilyIndexCount |
| &queueFamilyIndex, // pQueueFamilyIndices |
| VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout |
| }; |
| |
| handle = createImage(vk, device, &imageParams); |
| memory = alloc.allocate(getImageMemoryRequirements(vk, device, *handle), MemoryRequirement::Any); |
| |
| vk.bindImageMemory(device, *handle, memory->getMemory(), memory->getOffset()); |
| } |
| |
| // Helper class representing buffer |
| class BufferWrapper |
| { |
| public: |
| |
| BufferWrapper () = default; |
| void create (Context& context, SimpleAllocator& alloc, VkDeviceSize size, VkBufferUsageFlags usage); |
| |
| public: |
| Move<VkBuffer> handle; |
| MovePtr<Allocation> memory; |
| }; |
| |
| void BufferWrapper::create(Context& context, SimpleAllocator& alloc, VkDeviceSize size, VkBufferUsageFlags usage) |
| { |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice& device = context.getDevice(); |
| const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(size, usage); |
| |
| handle = createBuffer(vk, device, &bufferCreateInfo); |
| memory = alloc.allocate(getBufferMemoryRequirements(vk, device, *handle), MemoryRequirement::HostVisible); |
| |
| VK_CHECK(vk.bindBufferMemory(device, *handle, memory->getMemory(), memory->getOffset())); |
| } |
| |
| class NoneStageTestInstance : public vkt::TestInstance |
| { |
| public: |
| NoneStageTestInstance (Context& context, |
| const TestParams& testParams); |
| virtual ~NoneStageTestInstance (void) = default; |
| |
| tcu::TestStatus iterate (void) override; |
| |
| protected: |
| |
| VkAccessFlags2KHR getAccessFlag (VkAccessFlags2KHR access); |
| VkBufferImageCopy buildCopyRegion (VkExtent3D extent, |
| VkImageAspectFlags aspect); |
| void buildVertexBuffer (void); |
| Move<VkRenderPass> buildBasicRenderPass (VkFormat outputFormat, |
| VkImageLayout outputLayout, |
| VkAttachmentLoadOp loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE); |
| Move<VkRenderPass> buildComplexRenderPass (VkFormat intermediateFormat, |
| VkImageLayout intermediateLayout, |
| VkFormat outputFormat, |
| VkImageLayout outputLayout); |
| Move<VkImageView> buildImageView (VkImage image, |
| VkFormat format, |
| const VkImageSubresourceRange& subresourceRange); |
| Move<VkFramebuffer> buildFramebuffer (VkRenderPass renderPass, |
| const VkImageView* outView1, |
| const VkImageView* outView2 = DE_NULL); |
| Move<VkSampler> buildSampler (void); |
| Move<VkDescriptorSetLayout> buildDescriptorSetLayout (VkDescriptorType descriptorType); |
| Move<VkDescriptorPool> buildDescriptorPool (VkDescriptorType descriptorType); |
| Move<VkDescriptorSet> buildDescriptorSet (VkDescriptorPool descriptorPool, |
| VkDescriptorSetLayout descriptorSetLayout, |
| VkDescriptorType descriptorType, |
| VkImageView inputView, |
| VkImageLayout inputLayout, |
| const VkSampler* sampler = DE_NULL); |
| Move<VkPipeline> buildPipeline (deUint32 subpass, |
| VkImageAspectFlags resultAspect, |
| VkPipelineLayout pipelineLayout, |
| VkShaderModule vertShaderModule, |
| VkShaderModule fragShaderModule, |
| VkRenderPass renderPass); |
| bool verifyResult (const PixelBufferAccess& reference, |
| const PixelBufferAccess& result); |
| |
| private: |
| |
| const TestParams m_testParams; |
| |
| VkFormat m_referenceImageFormat; |
| VkFormat m_transitionImageFormat; |
| VkFormat m_readImageFormat; |
| VkImageSubresourceRange m_referenceSubresourceRange; |
| VkImageSubresourceRange m_transitionSubresourceRange; |
| VkImageSubresourceRange m_readSubresourceRange; |
| VkImageAspectFlags m_transitionImageAspect; |
| |
| VkExtent3D m_imageExtent; |
| VkImageLayout m_writeRenderPassOutputLayout; |
| |
| // flag indicating that graphics pipeline is constructed to write data to tested image |
| bool m_usePipelineToWrite; |
| |
| // flag indicating that graphics pipeline is constructed to read data from tested image |
| bool m_usePipelineToRead; |
| |
| // flag indicating that write pipeline should be constructed in a special way to fill stencil buffer |
| bool m_useStencilDuringWrite; |
| |
| // flag indicating that read pipeline should be constructed in a special way to use input attachment as a data source |
| bool m_useInputAttachmentToRead; |
| |
| VkPipelineStageFlags2KHR m_srcStageToNoneStageMask; |
| VkAccessFlags2KHR m_srcAccessToNoneAccessMask; |
| VkPipelineStageFlags2KHR m_dstStageFromNoneStageMask; |
| VkAccessFlags2KHR m_dstAccessFromNoneAccessMask; |
| |
| SimpleAllocator m_alloc; |
| |
| ImageWrapper m_referenceImage; |
| VkImageUsageFlags m_referenceImageUsage; |
| |
| // objects/variables initialized only when needed |
| ImageWrapper m_imageToWrite; |
| VkImageUsageFlags m_imageToWriteUsage; |
| |
| ImageWrapper m_imageToRead; |
| |
| BufferWrapper m_vertexBuffer; |
| std::vector<Move<VkImageView> > m_attachmentViews; |
| |
| std::string m_writeFragShaderName; |
| Move<VkShaderModule> m_writeVertShaderModule; |
| Move<VkShaderModule> m_writeFragShaderModule; |
| Move<VkRenderPass> m_writeRenderPass; |
| Move<VkSampler> m_writeSampler; |
| Move<VkDescriptorSetLayout> m_writeDescriptorSetLayout; |
| Move<VkDescriptorPool> m_writeDescriptorPool; |
| Move<VkDescriptorSet> m_writeDescriptorSet; |
| Move<VkPipelineLayout> m_writePipelineLayout; |
| Move<VkPipeline> m_writePipeline; |
| Move<VkFramebuffer> m_writeFramebuffer; |
| |
| std::string m_readFragShaderName; |
| Move<VkShaderModule> m_readVertShaderModule; |
| Move<VkShaderModule> m_readFragShaderModule; |
| Move<VkShaderModule> m_readFragShaderModule2; |
| Move<VkRenderPass> m_readRenderPass; |
| Move<VkSampler> m_readSampler; |
| Move<VkDescriptorSetLayout> m_readDescriptorSetLayout; |
| Move<VkDescriptorPool> m_readDescriptorPool; |
| Move<VkDescriptorSet> m_readDescriptorSet; |
| Move<VkPipelineLayout> m_readPipelineLayout; |
| Move<VkPipeline> m_readPipeline; |
| Move<VkFramebuffer> m_readFramebuffer; |
| }; |
| |
| NoneStageTestInstance::NoneStageTestInstance(Context& context, const TestParams& testParams) |
| : vkt::TestInstance(context) |
| , m_testParams (testParams) |
| , m_imageExtent { 32, 32, 1 } |
| , m_alloc (m_context.getDeviceInterface(), |
| m_context.getDevice(), |
| getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice())) |
| { |
| // note: for clarity whole configuration of whats going on in iterate method was moved here |
| |
| const auto writeLayout = m_testParams.writeLayout; |
| const auto writeAspect = m_testParams.writeAspect; |
| const auto readLayout = m_testParams.readLayout; |
| const auto readAspect = m_testParams.readAspect; |
| |
| // select format that will be used for test |
| if ((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) || (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT)) |
| { |
| m_transitionImageFormat = VK_FORMAT_D32_SFLOAT; |
| m_transitionImageAspect = VK_IMAGE_ASPECT_DEPTH_BIT; |
| m_writeRenderPassOutputLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; |
| } |
| else if ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) || (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT)) |
| { |
| m_transitionImageFormat = VK_FORMAT_S8_UINT; |
| m_transitionImageAspect = VK_IMAGE_ASPECT_STENCIL_BIT; |
| m_writeRenderPassOutputLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL; |
| } |
| else if ((writeAspect == IMAGE_ASPECT_DEPTH_STENCIL) || (readAspect == IMAGE_ASPECT_DEPTH_STENCIL)) |
| { |
| m_transitionImageFormat = VK_FORMAT_D24_UNORM_S8_UINT; |
| // note: in test we focus only on depth aspect; no need to check both in those cases |
| m_transitionImageAspect = VK_IMAGE_ASPECT_DEPTH_BIT; |
| m_writeRenderPassOutputLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; |
| } |
| else |
| { |
| m_transitionImageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| m_transitionImageAspect = VK_IMAGE_ASPECT_COLOR_BIT; |
| m_writeRenderPassOutputLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| } |
| |
| m_referenceSubresourceRange = { m_transitionImageAspect, 0u, 1u, 0u, 1u }; |
| m_transitionSubresourceRange = { m_transitionImageAspect, 0u, 1u, 0u, 1u }; |
| m_readSubresourceRange = { m_transitionImageAspect, 0u, 1u, 0u, 1u }; |
| m_referenceImageFormat = m_transitionImageFormat; |
| m_readImageFormat = m_transitionImageFormat; |
| m_referenceImageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| m_imageToWriteUsage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; |
| |
| // pipeline is not created for transfer and general layouts (general layouts in tests follow same path as transfer layouts) |
| m_usePipelineToWrite = (writeLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (writeLayout != VK_IMAGE_LAYOUT_GENERAL); |
| m_usePipelineToRead = (readLayout != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) && (readLayout != VK_IMAGE_LAYOUT_GENERAL); |
| m_useStencilDuringWrite = false; |
| |
| m_srcStageToNoneStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR; |
| m_srcAccessToNoneAccessMask = getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR); |
| m_dstStageFromNoneStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR; |
| m_dstAccessFromNoneAccessMask = getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR); |
| |
| // when graphics pipelines are not created only image with gradient is used for test |
| if (!m_usePipelineToWrite && !m_usePipelineToRead) |
| { |
| m_referenceImageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; |
| return; |
| } |
| |
| if (m_usePipelineToWrite) |
| { |
| // depth/stencil layouts need diferent configuration |
| if (writeAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) |
| { |
| if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT) |
| { |
| m_referenceImageFormat = VK_FORMAT_R32_SFLOAT; |
| m_referenceImageUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| m_referenceSubresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| m_writeFragShaderName = "frag-color-to-depth"; |
| } |
| else |
| { |
| m_referenceImageUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| m_useStencilDuringWrite = true; |
| m_writeFragShaderName = "frag-color-to-stencil"; |
| } |
| |
| m_srcStageToNoneStageMask = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR; |
| m_srcAccessToNoneAccessMask = getAccessFlag(VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR); |
| m_imageToWriteUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| } |
| else |
| { |
| m_referenceImageUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| m_srcStageToNoneStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR; |
| m_srcAccessToNoneAccessMask = getAccessFlag(VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR); |
| m_writeFragShaderName = "frag-color"; |
| m_imageToWriteUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| } |
| } |
| |
| if (m_usePipelineToRead) |
| { |
| m_dstStageFromNoneStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR; |
| m_dstAccessFromNoneAccessMask = getAccessFlag(VK_ACCESS_2_SHADER_READ_BIT_KHR); |
| |
| m_readSubresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| if ((readAspect | writeAspect) & VK_IMAGE_ASPECT_DEPTH_BIT) |
| m_readImageFormat = VK_FORMAT_R32_SFLOAT; |
| else if ((readAspect | writeAspect) & VK_IMAGE_ASPECT_STENCIL_BIT) |
| m_readImageFormat = VK_FORMAT_R8_UINT; |
| |
| // for layouts that operate on depth or stencil (not depth_stencil) use input attachment to read |
| if ((readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) && (readAspect != IMAGE_ASPECT_DEPTH_STENCIL)) |
| { |
| m_useInputAttachmentToRead = true; |
| m_readFragShaderName = "frag-depth-or-stencil-to-color"; |
| m_imageToWriteUsage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; |
| m_dstAccessFromNoneAccessMask = getAccessFlag(VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR); |
| |
| if (!m_usePipelineToWrite) |
| m_referenceImageUsage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; |
| } |
| else // use image sampler for color and depth_stencil layouts |
| { |
| m_useInputAttachmentToRead = false; |
| m_readFragShaderName = "frag-color"; |
| m_referenceImageUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| m_imageToWriteUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| |
| // for depth_stencil layouts we need to have depth_stencil_attachment usage |
| if (!m_usePipelineToWrite && (readAspect & VK_IMAGE_ASPECT_STENCIL_BIT)) |
| m_referenceImageUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| |
| // when we read stencil as color we need to use usampler2D |
| if (writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) |
| m_readFragShaderName = "frag-stencil-to-color"; |
| } |
| } |
| } |
| |
| VkAccessFlags2KHR NoneStageTestInstance::getAccessFlag(VkAccessFlags2KHR access) |
| { |
| if (m_testParams.useGenericAccessFlags) |
| { |
| switch (access) |
| { |
| case VK_ACCESS_2_HOST_READ_BIT_KHR: |
| case VK_ACCESS_2_TRANSFER_READ_BIT_KHR: |
| case VK_ACCESS_2_SHADER_READ_BIT_KHR: |
| case VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: |
| return VK_ACCESS_2_MEMORY_READ_BIT_KHR; |
| |
| case VK_ACCESS_2_HOST_WRITE_BIT_KHR: |
| case VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: |
| case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: |
| case VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: |
| return VK_ACCESS_2_MEMORY_WRITE_BIT_KHR; |
| |
| default: |
| TCU_THROW(TestError, "Unhandled access flag"); |
| } |
| } |
| return access; |
| } |
| |
| VkBufferImageCopy NoneStageTestInstance::buildCopyRegion(VkExtent3D extent, VkImageAspectFlags aspect) |
| { |
| return |
| { |
| 0u, // VkDeviceSize bufferOffset |
| extent.width, // deUint32 bufferRowLength |
| extent.height, // deUint32 bufferImageHeight |
| { aspect, 0u, 0u, 1u }, // VkImageSubresourceLayers imageSubresource |
| { 0, 0, 0 }, // VkOffset3D imageOffset |
| extent // VkExtent3D imageExtent |
| }; |
| } |
| |
| void NoneStageTestInstance::buildVertexBuffer() |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| std::vector<float> vertices |
| { |
| 1.0f, 1.0f, 0.0f, 1.0f, |
| -1.0f, 1.0f, 0.0f, 1.0f, |
| 1.0f, -1.0f, 0.0f, 1.0f, |
| -1.0f, -1.0f, 0.0f, 1.0f, |
| }; |
| m_vertexBuffer.create(m_context, m_alloc, sizeof(float) * vertices.size(), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); |
| |
| deMemcpy(m_vertexBuffer.memory->getHostPtr(), vertices.data(), vertices.size() * sizeof(float)); |
| flushAlloc(vk, device, *m_vertexBuffer.memory); |
| } |
| |
| Move<VkRenderPass> NoneStageTestInstance::buildBasicRenderPass(VkFormat outputFormat, VkImageLayout outputLayout, VkAttachmentLoadOp loadOp) |
| { |
| // output color/depth attachment |
| VkAttachmentDescription2 attachmentDescription |
| { |
| VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags |
| outputFormat, // VkFormat format |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples |
| loadOp, // VkAttachmentLoadOp loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp |
| loadOp, // VkAttachmentLoadOp stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout |
| outputLayout // VkImageLayout finalLayout |
| }; |
| |
| VkImageAspectFlags imageAspect = getImageAspectFlags(mapVkFormat(outputFormat)); |
| VkAttachmentReference2 attachmentRef |
| { |
| VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 0u, outputLayout, imageAspect |
| }; |
| |
| VkAttachmentReference2* pColorAttachment = DE_NULL; |
| VkAttachmentReference2* pDepthStencilAttachment = DE_NULL; |
| if (imageAspect == VK_IMAGE_ASPECT_COLOR_BIT) |
| pColorAttachment = &attachmentRef; |
| else |
| pDepthStencilAttachment = &attachmentRef; |
| |
| VkSubpassDescription2 subpassDescription |
| { |
| VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, |
| DE_NULL, |
| (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags |
| VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint |
| 0u, // deUint32 viewMask |
| 0u, // deUint32 inputAttachmentCount |
| DE_NULL, // const VkAttachmentReference2* pInputAttachments |
| !!pColorAttachment, // deUint32 colorAttachmentCount |
| pColorAttachment, // const VkAttachmentReference2* pColorAttachments |
| DE_NULL, // const VkAttachmentReference2* pResolveAttachments |
| pDepthStencilAttachment, // const VkAttachmentReference2* pDepthStencilAttachment |
| 0u, // deUint32 preserveAttachmentCount |
| DE_NULL // const deUint32* pPreserveAttachments |
| }; |
| |
| const VkRenderPassCreateInfo2 renderPassInfo |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, |
| DE_NULL, // const void* pNext |
| (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags |
| 1u, // deUint32 attachmentCount |
| &attachmentDescription, // const VkAttachmentDescription* pAttachments |
| 1u, // deUint32 subpassCount |
| &subpassDescription, // const VkSubpassDescription* pSubpasses |
| 0u, // deUint32 dependencyCount |
| DE_NULL, // const VkSubpassDependency* pDependencies |
| 0u, // deUint32 correlatedViewMaskCount |
| DE_NULL // const deUint32* pCorrelatedViewMasks |
| }; |
| |
| return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo);; |
| } |
| |
| Move<VkRenderPass> NoneStageTestInstance::buildComplexRenderPass(VkFormat intermediateFormat, VkImageLayout intermediateLayout, |
| VkFormat outputFormat, VkImageLayout outputLayout) |
| { |
| std::vector<VkAttachmentDescription2> attachmentDescriptions |
| { |
| // depth/stencil attachment (when used in read pipeline it loads data filed in write pipeline) |
| { |
| VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags |
| intermediateFormat, // VkFormat format |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples |
| VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp |
| intermediateLayout, // VkImageLayout initialLayout |
| intermediateLayout // VkImageLayout finalLayout |
| }, |
| // color attachment |
| { |
| VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags |
| outputFormat, // VkFormat format |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout |
| outputLayout // VkImageLayout finalLayout |
| } |
| }; |
| |
| VkImageAspectFlags intermediateAspect = getImageAspectFlags(mapVkFormat(intermediateFormat)); |
| VkImageAspectFlags outputAspect = getImageAspectFlags(mapVkFormat(outputFormat)); |
| std::vector<VkAttachmentReference2> attachmentRefs |
| { |
| { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 0u, intermediateLayout, intermediateAspect }, |
| { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, DE_NULL, 1u, outputLayout, outputAspect } |
| }; |
| |
| VkAttachmentReference2* pDepthStencilAttachment = &attachmentRefs[0]; |
| VkAttachmentReference2* pColorAttachment = &attachmentRefs[1]; |
| |
| std::vector<VkSubpassDescription2> subpassDescriptions |
| { |
| { |
| VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, |
| DE_NULL, |
| (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags |
| VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint |
| 0u, // deUint32 viewMask |
| 1u, // deUint32 inputAttachmentCount |
| pDepthStencilAttachment, // const VkAttachmentReference2* pInputAttachments |
| 1u, // deUint32 colorAttachmentCount |
| pColorAttachment, // const VkAttachmentReference2* pColorAttachments |
| DE_NULL, // const VkAttachmentReference2* pResolveAttachments |
| DE_NULL, // const VkAttachmentReference2* pDepthStencilAttachment |
| 0u, // deUint32 preserveAttachmentCount |
| DE_NULL // deUint32* pPreserveAttachments |
| } |
| }; |
| |
| const VkRenderPassCreateInfo2 renderPassInfo |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, |
| DE_NULL, // const void* pNext |
| (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags |
| (deUint32)attachmentDescriptions.size(), // deUint32 attachmentCount |
| attachmentDescriptions.data(), // const VkAttachmentDescription* pAttachments |
| (deUint32)subpassDescriptions.size(), // deUint32 subpassCount |
| subpassDescriptions.data(), // const VkSubpassDescription* pSubpasses |
| 0u, // deUint32 dependencyCount |
| DE_NULL, // const VkSubpassDependency* pDependencies |
| 0u, // deUint32 correlatedViewMaskCount |
| DE_NULL // const deUint32* pCorrelatedViewMasks |
| }; |
| |
| return vk::createRenderPass2(m_context.getDeviceInterface(), m_context.getDevice(), &renderPassInfo); |
| } |
| |
| Move<VkImageView> NoneStageTestInstance::buildImageView(VkImage image, VkFormat format, const VkImageSubresourceRange& subresourceRange) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| const VkImageViewCreateInfo imageViewParams |
| { |
| VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| 0u, // VkImageViewCreateFlags flags |
| image, // VkImage image |
| VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType |
| format, // VkFormat format |
| makeComponentMappingRGBA(), // VkComponentMapping components |
| subresourceRange, // VkImageSubresourceRange subresourceRange |
| }; |
| |
| return createImageView(vk, device, &imageViewParams); |
| } |
| |
| Move<VkFramebuffer> NoneStageTestInstance::buildFramebuffer(VkRenderPass renderPass, const VkImageView* outView1, const VkImageView* outView2) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| std::vector<VkImageView> imageViews = { *outView1 }; |
| if (outView2) |
| imageViews.push_back(*outView2); |
| |
| const VkFramebufferCreateInfo framebufferParams |
| { |
| VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| 0u, // VkFramebufferCreateFlags flags |
| renderPass, // VkRenderPass renderPass |
| (deUint32)imageViews.size(), // deUint32 attachmentCount |
| imageViews.data(), // const VkImageView* pAttachments |
| m_imageExtent.width, // deUint32 width |
| m_imageExtent.height, // deUint32 height |
| 1u, // deUint32 layers |
| }; |
| return createFramebuffer(vk, device, &framebufferParams); |
| } |
| |
| Move<VkSampler> NoneStageTestInstance::buildSampler() |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| const VkSamplerCreateInfo samplerInfo |
| { |
| VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| 0u, // VkSamplerCreateFlags flags |
| VK_FILTER_NEAREST, // VkFilter magFilter |
| VK_FILTER_NEAREST, // VkFilter minFilter |
| VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode |
| VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU |
| VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV |
| VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW |
| 0.0f, // float mipLodBias |
| VK_FALSE, // VkBool32 anisotropyEnable |
| 1.0f, // float maxAnisotropy |
| DE_FALSE, // VkBool32 compareEnable |
| VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp |
| 0.0f, // float minLod |
| 0.0f, // float maxLod |
| VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor |
| VK_FALSE, // VkBool32 unnormalizedCoords |
| }; |
| return createSampler(vk, device, &samplerInfo); |
| } |
| |
| Move<VkDescriptorSetLayout> NoneStageTestInstance::buildDescriptorSetLayout(VkDescriptorType descriptorType) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| return |
| DescriptorSetLayoutBuilder() |
| .addSingleSamplerBinding(descriptorType, VK_SHADER_STAGE_FRAGMENT_BIT, DE_NULL) |
| .build(vk, device); |
| } |
| |
| Move<VkDescriptorPool> NoneStageTestInstance::buildDescriptorPool(VkDescriptorType descriptorType) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| return |
| DescriptorPoolBuilder() |
| .addType(descriptorType, 1u) |
| .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); |
| } |
| |
| Move<VkDescriptorSet> NoneStageTestInstance::buildDescriptorSet(VkDescriptorPool descriptorPool, |
| VkDescriptorSetLayout descriptorSetLayout, |
| VkDescriptorType descriptorType, |
| VkImageView inputView, |
| VkImageLayout inputLayout, |
| const VkSampler* sampler) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| |
| const VkDescriptorImageInfo inputImageInfo = makeDescriptorImageInfo(sampler ? *sampler : 0u, inputView, inputLayout); |
| Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout); |
| |
| DescriptorSetUpdateBuilder() |
| .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), descriptorType, &inputImageInfo) |
| .update(vk, device); |
| |
| return descriptorSet; |
| } |
| |
| Move<VkPipeline> NoneStageTestInstance::buildPipeline(deUint32 subpass, |
| VkImageAspectFlags resultAspect, |
| VkPipelineLayout pipelineLayout, |
| VkShaderModule vertShaderModule, |
| VkShaderModule fragShaderModule, |
| VkRenderPass renderPass) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| const std::vector<VkViewport> viewports { makeViewport(m_imageExtent) }; |
| const std::vector<VkRect2D> scissors { makeRect2D(m_imageExtent) }; |
| const bool useDepth = resultAspect & VK_IMAGE_ASPECT_DEPTH_BIT; |
| const bool useStencil = resultAspect & VK_IMAGE_ASPECT_STENCIL_BIT; |
| |
| const VkStencilOpState stencilOpState = makeStencilOpState( |
| VK_STENCIL_OP_REPLACE, // stencil fail |
| VK_STENCIL_OP_REPLACE, // depth & stencil pass |
| VK_STENCIL_OP_REPLACE, // depth only fail |
| VK_COMPARE_OP_ALWAYS, // compare op |
| 1u, // compare mask |
| 1u, // write mask |
| 1u); // reference |
| |
| const VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags |
| useDepth, // VkBool32 depthTestEnable |
| useDepth, // VkBool32 depthWriteEnable |
| VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp |
| VK_FALSE, // VkBool32 depthBoundsTestEnable |
| useStencil, // VkBool32 stencilTestEnable |
| stencilOpState, // VkStencilOpState front |
| stencilOpState, // VkStencilOpState back |
| 0.0f, // float minDepthBounds |
| 1.0f, // float maxDepthBounds |
| }; |
| |
| return makeGraphicsPipeline( |
| vk, // DeviceInterface& vk |
| device, // VkDevice device |
| pipelineLayout, // VkPipelineLayout pipelineLayout |
| vertShaderModule, // VkShaderModule vertexShaderModule |
| DE_NULL, // VkShaderModule tessellationControlModule |
| DE_NULL, // VkShaderModule tessellationEvalModule |
| DE_NULL, // VkShaderModule geometryShaderModule |
| fragShaderModule, // VkShaderModule fragmentShaderModule |
| renderPass, // VkRenderPass renderPass |
| viewports, // std::vector<VkViewport>& viewports |
| scissors, // std::vector<VkRect2D>& scissors |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology |
| subpass, // deUint32 subpass |
| 0u, // deUint32 patchControlPoints |
| DE_NULL, // VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo |
| DE_NULL, // VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo |
| DE_NULL, // VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo |
| &depthStencilStateCreateInfo); // VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo |
| } |
| |
| tcu::TestStatus NoneStageTestInstance::iterate(void) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice& device = m_context.getDevice(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| VkQueue queue = m_context.getUniversalQueue(); |
| Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex); |
| Move<VkCommandBuffer> cmdBuffer = makeCommandBuffer(vk, device, *cmdPool); |
| const VkDeviceSize vertexBufferOffset = 0; |
| ImageWrapper* transitionImagePtr = &m_referenceImage; |
| ImageWrapper* imageToVerifyPtr = &m_referenceImage; |
| const deUint32 imageSizeInBytes = m_imageExtent.width * m_imageExtent.height * 4; |
| SynchronizationWrapperPtr synchronizationWrapper = getSynchronizationWrapper(m_testParams.type, vk, false); |
| const VkRect2D renderArea = makeRect2D(0, 0, m_imageExtent.width, m_imageExtent.height); |
| const VkBufferImageCopy transitionCopyRegion = buildCopyRegion(m_imageExtent, m_transitionImageAspect); |
| const VkBufferImageCopy colorCopyRegion = buildCopyRegion(m_imageExtent, VK_IMAGE_ASPECT_COLOR_BIT); |
| |
| // create image that will have gradient (without data atm) |
| m_referenceImage.create(m_context, m_alloc, m_referenceImageFormat, m_imageExtent, m_referenceImageUsage); |
| |
| // create buffer used for gradient data source |
| BufferWrapper srcBuffer; |
| srcBuffer.create(m_context, m_alloc, imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT); |
| |
| // generate gradient |
| std::vector<deUint32> referenceData (m_imageExtent.width * m_imageExtent.height); |
| tcu::TextureFormat referenceFormat (mapVkFormat(m_referenceImageFormat)); |
| PixelBufferAccess referencePBA (referenceFormat, m_imageExtent.width, m_imageExtent.height, m_imageExtent.depth, referenceData.data()); |
| fillWithComponentGradients(referencePBA, tcu::Vec4(0.0f), tcu::Vec4(1.0f)); |
| deMemcpy(srcBuffer.memory->getHostPtr(), referenceData.data(), static_cast<size_t>(imageSizeInBytes)); |
| flushAlloc(vk, device, *srcBuffer.memory); |
| |
| // create buffer for result transfer |
| BufferWrapper dstBuffer; |
| tcu::TextureFormat resultFormat (mapVkFormat(m_readImageFormat)); |
| dstBuffer.create(m_context, m_alloc, imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT); |
| |
| if (m_usePipelineToWrite || m_usePipelineToRead) |
| { |
| buildVertexBuffer(); |
| |
| // create image view for reference image (its always at index 0) |
| m_attachmentViews.push_back(buildImageView(*m_referenceImage.handle, m_referenceImageFormat, m_referenceSubresourceRange)); |
| |
| // create graphics pipeline used to write image data |
| if (m_usePipelineToWrite) |
| { |
| // create image that will be used as attachment to write to |
| m_imageToWrite.create(m_context, m_alloc, m_transitionImageFormat, m_imageExtent, m_imageToWriteUsage); |
| m_attachmentViews.push_back(buildImageView(*m_imageToWrite.handle, m_transitionImageFormat, m_transitionSubresourceRange)); |
| |
| m_writeVertShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0); |
| m_writeFragShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get(m_writeFragShaderName), 0); |
| |
| if (m_useStencilDuringWrite) |
| { |
| // this is used only for cases where writable layout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL |
| // in this case generated gradient is only used for verification |
| m_writeRenderPass = buildBasicRenderPass(m_transitionImageFormat, m_writeRenderPassOutputLayout, VK_ATTACHMENT_LOAD_OP_CLEAR); |
| m_writePipelineLayout = makePipelineLayout(vk, device, DE_NULL); |
| m_writePipeline = buildPipeline(0u, m_transitionImageAspect, *m_writePipelineLayout, |
| *m_writeVertShaderModule, *m_writeFragShaderModule, *m_writeRenderPass); |
| m_writeFramebuffer = buildFramebuffer(*m_writeRenderPass, &m_attachmentViews[1].get()); |
| } |
| else |
| { |
| m_writeRenderPass = buildBasicRenderPass(m_transitionImageFormat, m_writeRenderPassOutputLayout); |
| m_writeSampler = buildSampler(); |
| m_writeDescriptorSetLayout = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); |
| m_writeDescriptorPool = buildDescriptorPool(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); |
| m_writeDescriptorSet = buildDescriptorSet(*m_writeDescriptorPool, *m_writeDescriptorSetLayout, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, |
| *m_attachmentViews[0], VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, &m_writeSampler.get()); |
| m_writePipelineLayout = makePipelineLayout(vk, device, *m_writeDescriptorSetLayout); |
| m_writePipeline = buildPipeline(0u, m_transitionImageAspect, *m_writePipelineLayout, |
| *m_writeVertShaderModule, *m_writeFragShaderModule, *m_writeRenderPass); |
| m_writeFramebuffer = buildFramebuffer(*m_writeRenderPass, &m_attachmentViews[1].get()); |
| } |
| |
| transitionImagePtr = &m_imageToWrite; |
| imageToVerifyPtr = &m_imageToWrite; |
| } |
| |
| // create graphics pipeline used to read image data |
| if (m_usePipelineToRead) |
| { |
| m_imageToRead.create(m_context, m_alloc, m_readImageFormat, m_imageExtent, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); |
| m_attachmentViews.push_back(buildImageView(*m_imageToRead.handle, m_readImageFormat, m_readSubresourceRange)); |
| imageToVerifyPtr = &m_imageToRead; |
| |
| m_readVertShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0); |
| m_readFragShaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get(m_readFragShaderName), 0); |
| |
| if (m_useInputAttachmentToRead) |
| { |
| m_readDescriptorSetLayout = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT); |
| m_readDescriptorPool = buildDescriptorPool(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT); |
| m_readDescriptorSet = buildDescriptorSet(*m_readDescriptorPool, *m_readDescriptorSetLayout, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, |
| *m_attachmentViews[m_usePipelineToWrite], m_testParams.readLayout); |
| m_readRenderPass = buildComplexRenderPass(m_transitionImageFormat, m_testParams.readLayout, |
| m_readImageFormat, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); |
| m_readFramebuffer = buildFramebuffer(*m_readRenderPass, &m_attachmentViews[m_usePipelineToWrite].get(), |
| &m_attachmentViews[m_usePipelineToWrite+1].get()); |
| m_readPipelineLayout = makePipelineLayout(vk, device, *m_readDescriptorSetLayout); |
| m_readPipeline = buildPipeline(0u, VK_IMAGE_ASPECT_COLOR_BIT, *m_readPipelineLayout, |
| *m_readVertShaderModule, *m_readFragShaderModule, *m_readRenderPass); |
| } |
| else |
| { |
| m_readSampler = buildSampler(); |
| m_readDescriptorSetLayout = buildDescriptorSetLayout(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); |
| m_readDescriptorPool = buildDescriptorPool(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER); |
| m_readDescriptorSet = buildDescriptorSet(*m_readDescriptorPool, *m_readDescriptorSetLayout, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, |
| *m_attachmentViews[m_usePipelineToWrite], m_testParams.readLayout, &m_readSampler.get()); |
| m_readRenderPass = buildBasicRenderPass(m_readImageFormat, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); |
| m_readFramebuffer = buildFramebuffer(*m_readRenderPass, &m_attachmentViews[m_usePipelineToWrite + 1].get()); |
| m_readPipelineLayout = makePipelineLayout(vk, device, *m_readDescriptorSetLayout); |
| m_readPipeline = buildPipeline(0u, m_transitionImageAspect, *m_readPipelineLayout, |
| *m_readVertShaderModule, *m_readFragShaderModule, *m_readRenderPass); |
| } |
| } |
| } |
| |
| beginCommandBuffer(vk, *cmdBuffer); |
| |
| // write data from buffer with gradient to image (for stencil_attachment cases we dont need to do that) |
| if (!m_useStencilDuringWrite) |
| { |
| // wait for reference data to be in buffer |
| const VkBufferMemoryBarrier2KHR preBufferMemoryBarrier2 = makeBufferMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_HOST_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| getAccessFlag(VK_ACCESS_2_HOST_WRITE_BIT_KHR), // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_READ_BIT_KHR), // VkAccessFlags2KHR dstAccessMask |
| *srcBuffer.handle, // VkBuffer buffer |
| 0u, // VkDeviceSize offset |
| imageSizeInBytes // VkDeviceSize size |
| ); |
| |
| VkImageLayout copyBufferToImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; |
| if(m_testParams.writeLayout == VK_IMAGE_LAYOUT_GENERAL) |
| copyBufferToImageLayout = VK_IMAGE_LAYOUT_GENERAL; |
| |
| // change image layout so that we can copy to it data from buffer |
| const VkImageMemoryBarrier2KHR preImageMemoryBarrier2 = makeImageMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR), // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR), // VkAccessFlags2KHR dstAccessMask |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout |
| copyBufferToImageLayout, // VkImageLayout newLayout |
| *m_referenceImage.handle, // VkImage image |
| m_referenceSubresourceRange // VkImageSubresourceRange subresourceRange |
| ); |
| VkDependencyInfoKHR buffDependencyInfo = makeCommonDependencyInfo(DE_NULL, &preBufferMemoryBarrier2, &preImageMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &buffDependencyInfo); |
| |
| const VkBufferImageCopy* copyRegion = m_usePipelineToWrite ? &colorCopyRegion : &transitionCopyRegion; |
| vk.cmdCopyBufferToImage(*cmdBuffer, *srcBuffer.handle, *m_referenceImage.handle, copyBufferToImageLayout, 1u, copyRegion); |
| } |
| |
| if (m_usePipelineToWrite) |
| { |
| // wait till data is transfered to image (in all cases except when stencil_attachment is tested) |
| if (!m_useStencilDuringWrite) |
| { |
| const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR), // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| getAccessFlag(VK_ACCESS_2_SHADER_READ_BIT_KHR), // VkAccessFlags2KHR dstAccessMask |
| VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout |
| VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // VkImageLayout newLayout |
| *m_referenceImage.handle, // VkImage image |
| m_referenceSubresourceRange // VkImageSubresourceRange subresourceRange |
| ); |
| VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo); |
| } |
| |
| beginRenderPass(vk, *cmdBuffer, *m_writeRenderPass, *m_writeFramebuffer, renderArea, tcu::Vec4(0.0f ,0.0f, 0.0f, 1.0f)); |
| |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_writePipeline); |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &m_vertexBuffer.handle.get(), &vertexBufferOffset); |
| if (m_useStencilDuringWrite) |
| { |
| // when writing to stencil buffer draw single triangle (to simulate gradient over 1bit) |
| vk.cmdDraw(*cmdBuffer, 3u, 1u, 0u, 0u); |
| } |
| else |
| { |
| vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_writePipelineLayout, 0, 1, &m_writeDescriptorSet.get(), 0, DE_NULL); |
| vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u); |
| } |
| |
| endRenderPass(vk, *cmdBuffer); |
| } |
| |
| // use none stage to wait till data is transfered to image |
| { |
| const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2( |
| m_srcStageToNoneStageMask, // VkPipelineStageFlags2KHR srcStageMask |
| m_srcAccessToNoneAccessMask, // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_NONE_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| VK_ACCESS_2_NONE_KHR, // VkAccessFlags2KHR dstAccessMask |
| m_testParams.writeLayout, // VkImageLayout oldLayout |
| m_testParams.writeLayout, // VkImageLayout newLayout |
| *transitionImagePtr->handle, // VkImage image |
| m_transitionSubresourceRange // VkImageSubresourceRange subresourceRange |
| ); |
| VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo); |
| } |
| |
| // use all commands stage to change image layout |
| { |
| const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| VK_ACCESS_2_NONE_KHR, // VkAccessFlags2KHR srcAccessMask |
| m_dstStageFromNoneStageMask, // VkPipelineStageFlags2KHR dstStageMask |
| m_dstAccessFromNoneAccessMask, // VkAccessFlags2KHR dstAccessMask |
| m_testParams.writeLayout, // VkImageLayout oldLayout |
| m_testParams.readLayout, // VkImageLayout newLayout |
| *transitionImagePtr->handle, // VkImage image |
| m_transitionSubresourceRange // VkImageSubresourceRange subresourceRange |
| ); |
| VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo); |
| } |
| |
| VkImageLayout copyImageToBufferLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; |
| if (m_testParams.readLayout == VK_IMAGE_LAYOUT_GENERAL) |
| copyImageToBufferLayout = VK_IMAGE_LAYOUT_GENERAL; |
| |
| if (m_usePipelineToRead) |
| { |
| beginRenderPass(vk, *cmdBuffer, *m_readRenderPass, *m_readFramebuffer, renderArea); |
| |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_readPipeline); |
| vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_readPipelineLayout, 0, 1, &m_readDescriptorSet.get(), 0, DE_NULL); |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &m_vertexBuffer.handle.get(), &vertexBufferOffset); |
| vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u); |
| |
| endRenderPass(vk, *cmdBuffer); |
| |
| // wait till data is transfered to image |
| const VkImageMemoryBarrier2KHR imageMemoryBarrier2 = makeImageMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_READ_BIT_KHR), // VkAccessFlags2KHR dstAccessMask |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout |
| copyImageToBufferLayout, // VkImageLayout newLayout |
| *imageToVerifyPtr->handle, // VkImage image |
| m_readSubresourceRange // VkImageSubresourceRange subresourceRange |
| ); |
| VkDependencyInfoKHR dependencyInfo = makeCommonDependencyInfo(DE_NULL, DE_NULL, &imageMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &dependencyInfo); |
| } |
| |
| // read back image |
| { |
| const VkBufferImageCopy* copyRegion = m_usePipelineToRead ? &colorCopyRegion : &transitionCopyRegion; |
| vk.cmdCopyImageToBuffer(*cmdBuffer, *imageToVerifyPtr->handle, copyImageToBufferLayout, *dstBuffer.handle, 1u, copyRegion); |
| |
| const VkBufferMemoryBarrier2KHR postBufferMemoryBarrier2 = makeBufferMemoryBarrier2( |
| VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, // VkPipelineStageFlags2KHR srcStageMask |
| getAccessFlag(VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR), // VkAccessFlags2KHR srcAccessMask |
| VK_PIPELINE_STAGE_2_HOST_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask |
| getAccessFlag(VK_ACCESS_2_HOST_READ_BIT_KHR), // VkAccessFlags2KHR dstAccessMask |
| *dstBuffer.handle, // VkBuffer buffer |
| 0u, // VkDeviceSize offset |
| imageSizeInBytes // VkDeviceSize size |
| ); |
| VkDependencyInfoKHR bufDependencyInfo = makeCommonDependencyInfo(DE_NULL, &postBufferMemoryBarrier2); |
| synchronizationWrapper->cmdPipelineBarrier(*cmdBuffer, &bufDependencyInfo); |
| } |
| |
| endCommandBuffer(vk, *cmdBuffer); |
| |
| Move<VkFence> fence = createFence(vk, device); |
| VkCommandBufferSubmitInfoKHR cmdBuffersInfo = makeCommonCommandBufferSubmitInfo(*cmdBuffer); |
| synchronizationWrapper->addSubmitInfo(0u, DE_NULL, 1u, &cmdBuffersInfo, 0u, DE_NULL); |
| VK_CHECK(synchronizationWrapper->queueSubmit(queue, *fence)); |
| VK_CHECK(vk.waitForFences(device, 1, &fence.get(), VK_TRUE, ~0ull)); |
| |
| // read image data |
| invalidateAlloc(vk, device, *dstBuffer.memory); |
| PixelBufferAccess resultPBA(resultFormat, m_imageExtent.width, m_imageExtent.height, m_imageExtent.depth, dstBuffer.memory->getHostPtr()); |
| |
| // if result/reference is depth-stencil format then focus only on depth component |
| if (isCombinedDepthStencilType(referenceFormat.type)) |
| referencePBA = getEffectiveDepthStencilAccess(referencePBA, tcu::Sampler::MODE_DEPTH); |
| if (isCombinedDepthStencilType(resultFormat.type)) |
| resultPBA = getEffectiveDepthStencilAccess(resultPBA, tcu::Sampler::MODE_DEPTH); |
| |
| if (verifyResult(referencePBA, resultPBA)) |
| return TestStatus::pass("Pass"); |
| return TestStatus::fail("Fail"); |
| } |
| |
| bool NoneStageTestInstance::verifyResult(const PixelBufferAccess& reference, const PixelBufferAccess& result) |
| { |
| TestLog& log = m_context.getTestContext().getLog(); |
| |
| if (isIntFormat(m_referenceImageFormat) || isUintFormat(m_referenceImageFormat)) |
| { |
| // special case for stencil (1bit gradient - top-left of image is 0, bottom-right is 1) |
| |
| bool isResultCorrect = true; |
| TextureLevel errorMaskStorage(TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8), |
| m_imageExtent.width, m_imageExtent.height, 1); |
| PixelBufferAccess errorMask = errorMaskStorage.getAccess(); |
| |
| for (deUint32 y = 0; y < m_imageExtent.height; y++) |
| for (deUint32 x = 0; x < m_imageExtent.width; x++) |
| { |
| // skip textels on diagonal (gradient lights texels on diagonal and stencil operation in test does not) |
| if ((x + y) == (m_imageExtent.width - 1)) |
| { |
| errorMask.setPixel(IVec4(0, 0xff, 0, 0xff), x, y, 0); |
| continue; |
| } |
| |
| IVec4 refPix = reference.getPixelInt(x, y, 0); |
| IVec4 cmpPix = result.getPixelInt(x, y, 0); |
| bool isOk = (refPix[0] == cmpPix[0]); |
| errorMask.setPixel(isOk ? IVec4(0, 0xff, 0, 0xff) : IVec4(0xff, 0, 0, 0xff), x, y, 0); |
| isResultCorrect &= isOk; |
| } |
| |
| Vec4 pixelBias(0.0f); |
| Vec4 pixelScale(1.0f); |
| if (isResultCorrect) |
| { |
| log << TestLog::ImageSet("Image comparison", "") |
| << TestLog::Image("Result", "Result", result, pixelScale, pixelBias) |
| << TestLog::EndImageSet; |
| return true; |
| } |
| |
| log << TestLog::ImageSet("Image comparison", "") |
| << TestLog::Image("Result", "Result", result, pixelScale, pixelBias) |
| << TestLog::Image("Reference", "Reference", reference, pixelScale, pixelBias) |
| << TestLog::Image("ErrorMask", "Error mask", errorMask) |
| << TestLog::EndImageSet; |
| return false; |
| } |
| |
| return floatThresholdCompare(log, "Image comparison", "", reference, result, tcu::Vec4(0.01f), tcu::COMPARE_LOG_RESULT); |
| } |
| |
| class NoneStageTestCase : public vkt::TestCase |
| { |
| public: |
| NoneStageTestCase (tcu::TestContext& testContext, |
| const std::string& name, |
| const TestParams& testParams); |
| ~NoneStageTestCase (void) = default; |
| |
| void initPrograms (SourceCollections& sourceCollections) const override; |
| TestInstance* createInstance (Context& context) const override; |
| void checkSupport (Context& context) const override; |
| |
| private: |
| const TestParams m_testParams; |
| }; |
| |
| NoneStageTestCase::NoneStageTestCase(tcu::TestContext& testContext, const std::string& name, const TestParams& testParams) |
| : vkt::TestCase (testContext, name, "") |
| , m_testParams (testParams) |
| { |
| } |
| |
| void NoneStageTestCase::initPrograms(SourceCollections& sourceCollections) const |
| { |
| const auto writeLayout = m_testParams.writeLayout; |
| const auto writeAspect = m_testParams.writeAspect; |
| const auto readLayout = m_testParams.readLayout; |
| const auto readAspect = m_testParams.readAspect; |
| |
| // for tests that use only transfer and general layouts we don't create pipeline |
| if (((writeLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) || (readLayout == VK_IMAGE_LAYOUT_GENERAL)) && |
| ((writeLayout == VK_IMAGE_LAYOUT_GENERAL) || (readLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL))) |
| return; |
| |
| sourceCollections.glslSources.add("vert") << glu::VertexSource( |
| "#version 450\n" |
| "layout(location = 0) in vec4 inPosition;\n" |
| "layout(location = 0) out vec2 outUV;\n" |
| "void main(void)\n" |
| "{\n" |
| " outUV = vec2(inPosition.x * 0.5 + 0.5, inPosition.y * 0.5 + 0.5);\n" |
| " gl_Position = inPosition;\n" |
| "}\n" |
| ); |
| |
| sourceCollections.glslSources.add("frag-color") << glu::FragmentSource( |
| "#version 450\n" |
| "layout(binding = 0) uniform sampler2D u_sampler;\n" |
| "layout(location = 0) in vec2 inUV;\n" |
| "layout(location = 0) out vec4 fragColor;\n" |
| "void main(void)\n" |
| "{\n" |
| " fragColor = texture(u_sampler, inUV);\n" |
| "}\n" |
| ); |
| |
| if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT) |
| { |
| sourceCollections.glslSources.add("frag-color-to-depth") << glu::FragmentSource( |
| "#version 450\n" |
| "layout(binding = 0) uniform sampler2D u_sampler;\n" |
| "layout(location = 0) in vec2 inUV;\n" |
| "void main(void)\n" |
| "{\n" |
| " gl_FragDepth = texture(u_sampler, inUV).r;\n" |
| "}\n" |
| ); |
| } |
| |
| if (writeAspect & VK_IMAGE_ASPECT_STENCIL_BIT) |
| { |
| sourceCollections.glslSources.add("frag-color-to-stencil") << glu::FragmentSource( |
| "#version 450\n" |
| "void main(void)\n" |
| "{\n" |
| "}\n" |
| ); |
| |
| if ((readLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) || |
| ((readLayout == VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR) && (readAspect == IMAGE_ASPECT_ALL))) |
| { |
| // use usampler2D and uvec4 for color |
| sourceCollections.glslSources.add("frag-stencil-to-color") << glu::FragmentSource( |
| "#version 450\n" |
| "layout(binding = 0) uniform usampler2D u_sampler;\n" |
| "layout(location = 0) in vec2 inUV;\n" |
| "layout(location = 0) out uvec4 fragColor;\n" |
| "void main(void)\n" |
| "{\n" |
| " fragColor = texture(u_sampler, inUV);\n" |
| "}\n" |
| ); |
| } |
| } |
| |
| if (readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) |
| { |
| // for stencil only cases we need to use usubpassInput (for depth and depth_stencil we need to use subpassInput) |
| const bool readDepth = readAspect & VK_IMAGE_ASPECT_DEPTH_BIT; |
| const std::map<std::string, std::string> specializations |
| { |
| { "SUBPASS_INPUT", (readDepth ? "subpassInput" : "usubpassInput") }, |
| { "VALUE_TYPE", (readDepth ? "float" : "uint") } |
| }; |
| |
| std::string source = |
| "#version 450\n" |
| "layout (input_attachment_index = 0, binding = 0) uniform ${SUBPASS_INPUT} depthOrStencilInput;\n" |
| "layout(location = 0) in vec2 inUV;\n" |
| "layout(location = 0) out ${VALUE_TYPE} fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = subpassLoad(depthOrStencilInput).x;\n" |
| "}\n"; |
| sourceCollections.glslSources.add("frag-depth-or-stencil-to-color") |
| << glu::FragmentSource(tcu::StringTemplate(source).specialize(specializations)); |
| } |
| } |
| |
| TestInstance* NoneStageTestCase::createInstance(Context& context) const |
| { |
| return new NoneStageTestInstance(context, m_testParams); |
| } |
| |
| void NoneStageTestCase::checkSupport(Context& context) const |
| { |
| context.requireDeviceFunctionality("VK_KHR_synchronization2"); |
| |
| const auto writeAspect = m_testParams.writeAspect; |
| const auto readAspect = m_testParams.readAspect; |
| |
| // check whether implementation supports separate depth/stencil layouts |
| if (((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) && (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT)) || |
| ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) && (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT))) |
| { |
| if(!context.getSeparateDepthStencilLayoutsFeatures().separateDepthStencilLayouts) |
| TCU_THROW(NotSupportedError, "Implementation does not support separateDepthStencilLayouts"); |
| } |
| |
| const auto writeLayout = m_testParams.writeLayout; |
| const auto readLayout = m_testParams.readLayout; |
| bool usePipelineToWrite = (writeLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (writeLayout != VK_IMAGE_LAYOUT_GENERAL); |
| bool usePipelineToRead = (readLayout != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) && (readLayout != VK_IMAGE_LAYOUT_GENERAL); |
| |
| if (!usePipelineToWrite && !usePipelineToRead) |
| return; |
| |
| VkFormat transitionImageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| if ((writeAspect == VK_IMAGE_ASPECT_DEPTH_BIT) || (readAspect == VK_IMAGE_ASPECT_DEPTH_BIT)) |
| transitionImageFormat = VK_FORMAT_D32_SFLOAT; |
| else if ((writeAspect == VK_IMAGE_ASPECT_STENCIL_BIT) || (readAspect == VK_IMAGE_ASPECT_STENCIL_BIT)) |
| transitionImageFormat = VK_FORMAT_S8_UINT; |
| else if ((writeAspect == IMAGE_ASPECT_DEPTH_STENCIL) || (readAspect == IMAGE_ASPECT_DEPTH_STENCIL)) |
| transitionImageFormat = VK_FORMAT_D24_UNORM_S8_UINT; |
| |
| struct FormatToCheck |
| { |
| VkFormat format; |
| VkImageUsageFlags usage; |
| }; |
| std::vector<FormatToCheck> formatsToCheck |
| { |
| // reference image |
| { transitionImageFormat, (VkImageUsageFlags)VK_IMAGE_USAGE_TRANSFER_DST_BIT }, |
| |
| // image to write |
| { transitionImageFormat, (VkImageUsageFlags)VK_IMAGE_USAGE_TRANSFER_SRC_BIT } |
| }; |
| |
| // note: conditions here are analogic to conditions in test case constructor |
| // everything not needed was cout out leaving only logic related to |
| // m_referenceImage and m_imageToWrite |
| if (usePipelineToWrite) |
| { |
| if (writeAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) |
| { |
| if (writeAspect & VK_IMAGE_ASPECT_DEPTH_BIT) |
| { |
| formatsToCheck[0].format = VK_FORMAT_R32_SFLOAT; |
| formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| } |
| else |
| formatsToCheck[0].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| |
| formatsToCheck[1].usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| } |
| else |
| { |
| formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| formatsToCheck[1].usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| } |
| } |
| |
| if (usePipelineToRead) |
| { |
| // for layouts that operate on depth or stencil (not depth_stencil) use input attachment to read |
| if ((readAspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) && (readAspect != IMAGE_ASPECT_DEPTH_STENCIL)) |
| { |
| formatsToCheck[1].usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; |
| |
| if (!usePipelineToWrite) |
| formatsToCheck[0].usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; |
| } |
| else // use image sampler for color and depth_stencil layouts |
| { |
| formatsToCheck[0].usage |= VK_IMAGE_USAGE_SAMPLED_BIT; |
| |
| // for depth_stencil layouts we need to have depth_stencil_attachment usage |
| if (!usePipelineToWrite && (readAspect & VK_IMAGE_ASPECT_STENCIL_BIT)) |
| formatsToCheck[0].usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| } |
| } |
| |
| // it simplifies logic to pop image to write then to add conditions everywhere above |
| if (!usePipelineToWrite) |
| formatsToCheck.pop_back(); |
| |
| for (const auto& formatData : formatsToCheck) |
| { |
| VkImageFormatProperties properties; |
| const vk::InstanceInterface& vki = context.getInstanceInterface(); |
| if (vki.getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(), |
| formatData.format, |
| VK_IMAGE_TYPE_2D, |
| VK_IMAGE_TILING_OPTIMAL, |
| formatData.usage, |
| 0, |
| &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) |
| { |
| std::string error = std::string("Format (") + |
| vk::getFormatName(formatData.format) + ") doesn't support required capabilities."; |
| TCU_THROW(NotSupportedError, error.c_str()); |
| } |
| } |
| } |
| |
| } // anonymous |
| |
| tcu::TestCaseGroup* createNoneStageTests(tcu::TestContext& testCtx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> noneStageTests(new tcu::TestCaseGroup(testCtx, "none_stage", "")); |
| |
| struct LayoutData |
| { |
| VkImageLayout token; |
| VkImageAspectFlags aspect; |
| std::string name; |
| }; |
| |
| const std::vector<LayoutData> writableLayoutsData |
| { |
| { VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, IMAGE_ASPECT_ALL, "transfer_dst" }, |
| { VK_IMAGE_LAYOUT_GENERAL, IMAGE_ASPECT_ALL, "general" }, |
| { VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT, "color_attachment" }, |
| { VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, IMAGE_ASPECT_DEPTH_STENCIL, "depth_stencil_attachment" }, |
| { VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT, "depth_attachment" }, |
| { VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_STENCIL_BIT, "stencil_attachment" }, |
| { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_ASPECT_COLOR_BIT, "generic_color_attachment" }, |
| { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_ASPECT_DEPTH_BIT, "generic_depth_attachment" }, |
| { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_ASPECT_STENCIL_BIT, "generic_stencil_attachment" }, |
| { VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, IMAGE_ASPECT_DEPTH_STENCIL, "generic_depth_stencil_attachment" }, |
| }; |
| const std::vector<LayoutData> readableLayoutsData |
| { |
| { VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, IMAGE_ASPECT_ALL, "transfer_src" }, |
| { VK_IMAGE_LAYOUT_GENERAL, IMAGE_ASPECT_ALL, "general" }, |
| { VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, IMAGE_ASPECT_ALL, "shader_read" }, |
| { VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, IMAGE_ASPECT_DEPTH_STENCIL, "depth_stencil_read" }, |
| { VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, IMAGE_ASPECT_DEPTH_STENCIL, "depth_read_stencil_attachment" }, |
| { VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, IMAGE_ASPECT_DEPTH_STENCIL, "depth_attachment_stencil_read" }, |
| { VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT, "depth_read" }, |
| { VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_STENCIL_BIT, "stencil_read" }, |
| { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, IMAGE_ASPECT_ALL, "generic_color_read" }, |
| { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_ASPECT_DEPTH_BIT, "generic_depth_read" }, |
| { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_ASPECT_STENCIL_BIT, "generic_stencil_read" }, |
| { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, IMAGE_ASPECT_DEPTH_STENCIL, "generic_depth_stencil_read" }, |
| }; |
| |
| struct SynchronizationData |
| { |
| SynchronizationType type; |
| std::string casePrefix; |
| bool useGenericAccessFlags; |
| }; |
| std::vector<SynchronizationData> synchronizationData |
| { |
| { SynchronizationType::SYNCHRONIZATION2, "", true }, |
| { SynchronizationType::SYNCHRONIZATION2, "old_access_", false }, |
| |
| // using legacy synchronization structures with NONE_STAGE |
| { SynchronizationType::LEGACY, "legacy_", false } |
| }; |
| |
| for (const auto& syncData : synchronizationData) |
| { |
| for (const auto& writeData : writableLayoutsData) |
| { |
| for (const auto& readData : readableLayoutsData) |
| { |
| if (readData.aspect && writeData.aspect && |
| (readData.aspect != writeData.aspect)) |
| continue; |
| |
| const std::string name = syncData.casePrefix + writeData.name + "_to_" + readData.name; |
| noneStageTests->addChild(new NoneStageTestCase(testCtx, name, { |
| syncData.type, |
| syncData.useGenericAccessFlags, |
| writeData.token, |
| writeData.aspect, |
| readData.token, |
| readData.aspect |
| })); |
| } |
| } |
| } |
| |
| return noneStageTests.release(); |
| } |
| |
| } // synchronization |
| } // vkt |
