--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation.
+ *
+ * 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
+ * \brief Tests vkCmdClearAttachments with unused attachments.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktRenderPassMultipleSubpassesMultipleCommandBuffersTests.hpp"
+#include "pipeline/vktPipelineImageUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkObjUtil.hpp"
+#include "vkImageUtil.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuImageCompare.hpp"
+#include <sstream>
+#include <functional>
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace vkt
+{
+namespace renderpass
+{
+
+namespace
+{
+
+struct Vertex
+{
+ tcu::Vec4 position;
+ tcu::Vec4 color;
+};
+
+template<typename T>
+inline VkDeviceSize sizeInBytes(const std::vector<T>& vec)
+{
+ return vec.size() * sizeof(vec[0]);
+}
+
+std::vector<Vertex> genVertices (void)
+{
+ std::vector<Vertex> vectorData;
+ const tcu::Vec4 red = {1.0f, 0.0f, 0.0f, 1.0f};
+ const tcu::Vec4 green = {0.0f, 1.0f, 0.0f, 1.0f};
+ const tcu::Vec4 blue = {0.0f, 0.0f, 1.0f, 1.0f};
+ const tcu::Vec4 yellow = {1.0f, 1.0f, 0.0f, 1.0f};
+
+ vectorData.push_back({tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f) , red});
+ vectorData.push_back({tcu::Vec4( 0.0f, -1.0f, 0.0f, 1.0f) , red});
+ vectorData.push_back({tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f) , red});
+ vectorData.push_back({tcu::Vec4( 0.0f, 1.0f, 0.0f, 1.0f) , red});
+
+ vectorData.push_back({tcu::Vec4( 0.0f, -1.0f, 0.0f, 1.0f) , green});
+ vectorData.push_back({tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f) , green});
+ vectorData.push_back({tcu::Vec4( 0.0f, 1.0f, 0.0f, 1.0f) , green});
+ vectorData.push_back({tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f) , green});
+
+ vectorData.push_back({tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f) , blue});
+ vectorData.push_back({tcu::Vec4( 0.0f, -1.0f, 0.0f, 1.0f) , blue});
+ vectorData.push_back({tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f) , blue});
+ vectorData.push_back({tcu::Vec4( 0.0f, 1.0f, 0.0f, 1.0f) , blue});
+
+ vectorData.push_back({tcu::Vec4( 0.0f, -1.0f, 0.0f, 1.0f) , yellow});
+ vectorData.push_back({tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f) , yellow});
+ vectorData.push_back({tcu::Vec4( 0.0f, 1.0f, 0.0f, 1.0f) , yellow});
+ vectorData.push_back({tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f) , yellow});
+
+ return vectorData;
+}
+
+class MultipleSubpassesMultipleCommandBuffersTestInstance : public TestInstance
+{
+public:
+ MultipleSubpassesMultipleCommandBuffersTestInstance (Context& context);
+ virtual ~MultipleSubpassesMultipleCommandBuffersTestInstance (void) {}
+ virtual tcu::TestStatus iterate (void);
+ void createCommandBuffer (const DeviceInterface& vk,
+ VkDevice vkDevice);
+private:
+ static constexpr deUint32 kImageWidth = 32;
+ static constexpr deUint32 kImageHeight = 32;
+ const tcu::UVec2 m_renderSize = { kImageWidth, kImageHeight };
+
+ // FIXME: check if I need all of this.
+ VkClearValue m_initialColor;
+ VkClearValue m_clearColor;
+
+ Move<VkImage> m_colorImageA;
+ de::MovePtr<Allocation> m_colorImageAllocA;
+ Move<VkImageView> m_colorAttachmentViewA;
+
+ Move<VkImage> m_colorImageB;
+ de::MovePtr<Allocation> m_colorImageAllocB;
+ Move<VkImageView> m_colorAttachmentViewB;
+
+ Move<VkRenderPass> m_renderPass;
+ Move<VkFramebuffer> m_framebufferA;
+ Move<VkFramebuffer> m_framebufferB;
+ Move<VkShaderModule> m_vertexShaderModule;
+ Move<VkShaderModule> m_fragmentShaderModule;
+ Move<VkDescriptorSetLayout> m_descriptorSetLayout;
+ Move<VkPipelineLayout> m_pipelineLayout;
+ Move<VkPipeline> m_graphicsPipeline0;
+ Move<VkPipeline> m_graphicsPipeline1;
+ Move<VkPipeline> m_graphicsPipeline2;
+ Move<VkCommandPool> m_cmdPool;
+ Move<VkCommandBuffer> m_cmdBufferA;
+ Move<VkCommandBuffer> m_cmdBufferB;
+
+ Move<VkBuffer> m_vertexBuffer;
+ de::MovePtr<Allocation> m_vertexBufferAlloc;
+};
+
+class MultipleSubpassesMultipleCommandBuffersTest : public vkt::TestCase
+{
+public:
+ MultipleSubpassesMultipleCommandBuffersTest (tcu::TestContext& testContext,
+ const std::string& name,
+ const std::string& description)
+ : vkt::TestCase(testContext, name, description)
+ {}
+ virtual ~MultipleSubpassesMultipleCommandBuffersTest (void) {}
+ virtual void initPrograms (SourceCollections& sourceCollections) const;
+ virtual TestInstance* createInstance (Context& context) const;
+};
+
+TestInstance* MultipleSubpassesMultipleCommandBuffersTest::createInstance (Context& context) const
+{
+ return new MultipleSubpassesMultipleCommandBuffersTestInstance(context);
+}
+
+void MultipleSubpassesMultipleCommandBuffersTest::initPrograms (SourceCollections& sourceCollections) const
+{
+ // Vertex shader.
+ sourceCollections.glslSources.add("vert_shader") << glu::VertexSource(
+ "#version 450\n"
+ "layout(location = 0) in vec4 position;\n"
+ "layout(location = 1) in vec4 color;\n"
+ "layout(location = 0) out vec4 vtxColor;\n"
+ "void main (void)\n"
+ "{\n"
+ "\tgl_Position = position;\n"
+ "\tvtxColor = color;\n"
+ "}\n");
+
+ // Fragment shader.
+ std::ostringstream fragmentSource;
+
+ fragmentSource << "#version 450\n"
+ << "layout(location = 0) in vec4 vtxColor;\n"
+ << "layout(location = 0) out vec4 fragColor;\n"
+ << "void main (void)\n"
+ << "{\n"
+ << "\tfragColor = vtxColor;\n"
+ << "}\n";
+
+ sourceCollections.glslSources.add("frag_shader") << glu::FragmentSource(fragmentSource.str());
+}
+
+// Create a render pass for this use case.
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice vkDevice)
+{
+ // XXX: Add more code to this
+ // Create attachment descriptions.
+ const VkAttachmentDescription attachmentDescription =
+ {
+ (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags
+ VK_FORMAT_R32G32B32A32_SFLOAT, // 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_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout
+ };
+
+ // XXX: Review this parameters, I think I am doing it wrong.
+ // Mark attachments as used or not depending on the test parameters.
+ const VkAttachmentReference attachmentReference
+ {
+ 0u, // deUint32 attachment
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout layout
+ };
+
+ // Create subpass description with the previous color attachment references.
+ std::vector<vk::VkSubpassDescription> subpassDescriptions;
+ {
+ const vk::VkSubpassDescription subpassDescription =
+ {
+ (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags
+ VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
+ 0u, // deUint32 inputAttachmentCount
+ DE_NULL, // const VkAttachmentReference* pInputAttachments
+ 1u, // deUint32 colorAttachmentCount
+ &attachmentReference, // const VkAttachmentReference* pColorAttachments
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments
+ DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
+ 0u, // deUint32 preserveAttachmentCount
+ DE_NULL // const deUint32* pPreserveAttachments
+ };
+ subpassDescriptions.emplace_back(subpassDescription);
+ subpassDescriptions.emplace_back(subpassDescription);
+ subpassDescriptions.emplace_back(subpassDescription);
+ }
+
+ std::vector<vk::VkSubpassDependency> subpassDependencies;
+ {
+ vk::VkSubpassDependency subpassDependency =
+ {
+ 0u, // deUint32 srcSubpass
+ 1u, // deUint32 dstSubpass
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags dstStageMask
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
+ 0u // VkDependencyFlags dependencyFlags
+ };
+ subpassDependencies.emplace_back(subpassDependency);
+ subpassDependency.srcSubpass = 1u;
+ subpassDependency.dstSubpass = 2u;
+ subpassDependencies.emplace_back(subpassDependency);
+ }
+
+
+ const vk::VkRenderPassCreateInfo renderPassInfo =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags
+ 1u, // deUint32 attachmentCount
+ &attachmentDescription, // const VkAttachmentDescription* pAttachments
+ static_cast<deUint32>(subpassDescriptions.size()), // deUint32 subpassCount
+ subpassDescriptions.data(), // const VkSubpassDescription* pSubpasses
+ static_cast<deUint32>(subpassDependencies.size()), // deUint32 dependencyCount
+ subpassDependencies.data(), // const VkSubpassDependency* pDependencies
+ };
+
+ return createRenderPass(vk, vkDevice, &renderPassInfo);
+}
+
+MultipleSubpassesMultipleCommandBuffersTestInstance::MultipleSubpassesMultipleCommandBuffersTestInstance(Context& context)
+ : vkt::TestInstance(context)
+{
+ // Initial color for all images.
+ m_initialColor.color.float32[0] = 0.0f;
+ m_initialColor.color.float32[1] = 0.0f;
+ m_initialColor.color.float32[2] = 0.0f;
+ m_initialColor.color.float32[3] = 1.0f;
+
+ // Clear color for used attachments.
+ m_clearColor.color.float32[0] = 1.0f;
+ m_clearColor.color.float32[1] = 1.0f;
+ m_clearColor.color.float32[2] = 1.0f;
+ m_clearColor.color.float32[3] = 1.0f;
+
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
+ const VkComponentMapping componentMapping = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
+
+ // Create color images.
+ {
+ const VkImageCreateInfo colorImageParams =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkImageCreateFlags flags;
+ VK_IMAGE_TYPE_2D, // VkImageType imageType;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ { kImageWidth, kImageHeight, 1u }, // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ 1u, // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
+ | VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 1u, // deUint32 queueFamilyIndexCount;
+ &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
+ };
+ // Create, allocate and bind image memory.
+ m_colorImageA = createImage(vk, vkDevice, &colorImageParams);
+ m_colorImageAllocA = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImageA), MemoryRequirement::Any);
+ VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImageA, m_colorImageAllocA->getMemory(), m_colorImageAllocA->getOffset()));
+
+ m_colorImageB = createImage(vk, vkDevice, &colorImageParams);
+ m_colorImageAllocB = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImageB), MemoryRequirement::Any);
+ VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImageB, m_colorImageAllocB->getMemory(), m_colorImageAllocB->getOffset()));
+
+ // Create image view.
+ {
+ const VkImageViewCreateInfo colorAttachmentViewParamsA =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkImageViewCreateFlags flags;
+ *m_colorImageA, // VkImage image;
+ VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ componentMapping, // VkChannelMapping channels;
+ { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
+ };
+ m_colorAttachmentViewA = createImageView(vk, vkDevice, &colorAttachmentViewParamsA);
+
+ const VkImageViewCreateInfo colorAttachmentViewParamsB =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkImageViewCreateFlags flags;
+ *m_colorImageB, // VkImage image;
+ VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
+ componentMapping, // VkChannelMapping channels;
+ { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
+ };
+ m_colorAttachmentViewB = createImageView(vk, vkDevice, &colorAttachmentViewParamsB);
+ }
+
+ // Clear image and leave it prepared to be used as a color attachment.
+ {
+ const VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ Move<VkCommandPool> cmdPool;
+ Move<VkCommandBuffer> cmdBuffer;
+ std::vector<VkImageMemoryBarrier> preImageBarriers;
+ std::vector<VkImageMemoryBarrier> postImageBarriers;
+
+ // Create command pool and buffer
+ cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
+ cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+
+ // From undefined layout to VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
+ const VkImageMemoryBarrier preImageBarrierA =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkAccessFlags srcAccessMask;
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ *m_colorImageA, // VkImage image;
+ { // VkImageSubresourceRange subresourceRange;
+ aspectMask, // VkImageAspect aspect;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u // deUint32 arraySize;
+ }
+ };
+
+ preImageBarriers.emplace_back(preImageBarrierA);
+
+ // From VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL.
+ const VkImageMemoryBarrier postImageBarrierA =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
+ VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask;
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ *m_colorImageA, // VkImage image;
+ { // VkImageSubresourceRange subresourceRange;
+ aspectMask, // VkImageAspect aspect;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u // deUint32 arraySize;
+ }
+ };
+
+ postImageBarriers.emplace_back(postImageBarrierA);
+
+ // From undefined layout to VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
+ const VkImageMemoryBarrier preImageBarrierB =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkAccessFlags srcAccessMask;
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ *m_colorImageB, // VkImage image;
+ { // VkImageSubresourceRange subresourceRange;
+ aspectMask, // VkImageAspect aspect;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u // deUint32 arraySize;
+ }
+ };
+
+ preImageBarriers.emplace_back(preImageBarrierB);
+
+ // From VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL.
+ const VkImageMemoryBarrier postImageBarrierB =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
+ VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask;
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ *m_colorImageB, // VkImage image;
+ { // VkImageSubresourceRange subresourceRange;
+ aspectMask, // VkImageAspect aspect;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 mipLevels;
+ 0u, // deUint32 baseArraySlice;
+ 1u // deUint32 arraySize;
+ }
+ };
+
+ postImageBarriers.emplace_back(postImageBarrierB);
+
+ const VkImageSubresourceRange clearRange =
+ {
+ aspectMask, // VkImageAspectFlags aspectMask;
+ 0u, // deUint32 baseMipLevel;
+ 1u, // deUint32 levelCount;
+ 0u, // deUint32 baseArrayLayer;
+ 1u // deUint32 layerCount;
+ };
+
+ // Clear image and transfer layout.
+ beginCommandBuffer(vk, *cmdBuffer);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, static_cast<deUint32>(preImageBarriers.size()), preImageBarriers.data());
+ vk.cmdClearColorImage(*cmdBuffer, *m_colorImageA, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_initialColor.color, 1, &clearRange);
+ vk.cmdClearColorImage(*cmdBuffer, *m_colorImageB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_initialColor.color, 1, &clearRange);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, static_cast<deUint32>(postImageBarriers.size()), postImageBarriers.data());
+ endCommandBuffer(vk, *cmdBuffer);
+
+ submitCommandsAndWait(vk, vkDevice, m_context.getUniversalQueue(), cmdBuffer.get());
+ }
+ }
+
+ // Create render pass.
+ m_renderPass = createRenderPass(vk, vkDevice);
+
+ // Create framebuffer
+ {
+ const VkImageView attachmentBindInfosA[1] =
+ {
+ *m_colorAttachmentViewA,
+ };
+ const VkFramebufferCreateInfo framebufferParamsA =
+ {
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkFramebufferCreateFlags flags;
+ *m_renderPass, // VkRenderPass renderPass;
+ 1u, // deUint32 attachmentCount;
+ attachmentBindInfosA, // const VkImageView* pAttachments;
+ kImageWidth, // deUint32 width;
+ kImageHeight, // deUint32 height;
+ 1u // deUint32 layers;
+ };
+
+ m_framebufferA = createFramebuffer(vk, vkDevice, &framebufferParamsA);
+
+ const VkImageView attachmentBindInfosB[1] =
+ {
+ *m_colorAttachmentViewB,
+ };
+ const VkFramebufferCreateInfo framebufferParamsB =
+ {
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkFramebufferCreateFlags flags;
+ *m_renderPass, // VkRenderPass renderPass;
+ 1u, // deUint32 attachmentCount;
+ attachmentBindInfosB, // const VkImageView* pAttachments;
+ kImageWidth, // deUint32 width;
+ kImageHeight, // deUint32 height;
+ 1u // deUint32 layers;
+ };
+
+ m_framebufferB = createFramebuffer(vk, vkDevice, &framebufferParamsB);
+ }
+
+ // Create pipeline layout.
+ {
+ const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutParams =
+ {
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0u, // VkDescriptorSetLayoutCreateFlags flags
+ 0u, // deUint32 bindingCount
+ DE_NULL // const VkDescriptorSetLayoutBinding* pBindings
+ };
+ m_descriptorSetLayout = createDescriptorSetLayout(vk, vkDevice, &descriptorSetLayoutParams);
+
+ const VkPipelineLayoutCreateInfo pipelineLayoutParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineLayoutCreateFlags flags;
+ 1u, // deUint32 setLayoutCount;
+ &m_descriptorSetLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
+ 0u, // deUint32 pushConstantRangeCount;
+ DE_NULL // const VkPushConstantRange* pPushConstantRanges;
+ };
+
+ m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
+ }
+
+ // Create Vertex buffer
+ {
+ const std::vector<Vertex> vertexValues = genVertices();
+ const VkDeviceSize vertexBufferSize = sizeInBytes(vertexValues);
+
+ const vk::VkBufferCreateInfo bufferCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0u, // VkBufferCreateFlags flags
+ vertexBufferSize, // VkDeviceSize size
+ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
+ 1u, // deUint32 queueFamilyIndexCount
+ &queueFamilyIndex // const deUint32* pQueueFamilyIndices
+ };
+
+ m_vertexBuffer = createBuffer(vk, vkDevice, &bufferCreateInfo);
+ m_vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_vertexBuffer), MemoryRequirement::HostVisible);
+ VK_CHECK(vk.bindBufferMemory(vkDevice, *m_vertexBuffer, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset()));
+ // Load vertices into vertex buffer
+ deMemcpy(m_vertexBufferAlloc->getHostPtr(), vertexValues.data(), static_cast<size_t>(vertexBufferSize));
+ flushAlloc(vk, vkDevice, *m_vertexBufferAlloc);
+ }
+
+ // Vertex buffer description
+ const vk::VkVertexInputBindingDescription bindingDescription =
+ {
+ 0u, // deUint32 binding
+ sizeof(Vertex), // deUint32 stride
+ VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate
+ };
+
+ std::vector<vk::VkVertexInputAttributeDescription> attributeDescriptions;
+ {
+ vk::VkVertexInputAttributeDescription attributeDescriptionVertex =
+ {
+ 0u, // deUint32 location
+ 0u, // deUint32 binding
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format
+ offsetof(Vertex, position) // deUint32 offset
+ };
+
+ vk::VkVertexInputAttributeDescription attributeDescriptionColor =
+ {
+ 1u, // deUint32 location
+ 0u, // deUint32 binding
+ VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format
+ offsetof(Vertex, color) // deUint32 offset
+ };
+ attributeDescriptions.emplace_back(attributeDescriptionVertex);
+ attributeDescriptions.emplace_back(attributeDescriptionColor);
+ }
+
+ const vk::VkPipelineVertexInputStateCreateInfo vertexInputState =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0u, // VkPipelineVertexInputStateCreateFlags flags
+ 1u, // deUint32 vertexBindingDescriptionCount
+ &bindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions
+ static_cast<deUint32>(attributeDescriptions.size()), // deUint32 vertexAttributeDescriptionCount
+ attributeDescriptions.data(), // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
+ };
+
+ m_vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert_shader"), 0);
+ m_fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag_shader"), 0);
+
+ // Create pipeline.
+ {
+ const std::vector<VkViewport> viewports (1, makeViewport(m_renderSize));
+ const std::vector<VkRect2D> scissors (1, makeRect2D(m_renderSize));
+
+ const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
+ {
+ VK_FALSE, // VkBool32 blendEnable
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor
+ VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor
+ VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor
+ VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp
+ VK_COLOR_COMPONENT_R_BIT // VkColorComponentFlags colorWriteMask
+ | VK_COLOR_COMPONENT_G_BIT
+ | VK_COLOR_COMPONENT_B_BIT
+ | VK_COLOR_COMPONENT_A_BIT
+ };
+
+ const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0u, // VkPipelineColorBlendStateCreateFlags flags
+ VK_FALSE, // VkBool32 logicOpEnable
+ VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp
+ 1u, // deUint32 attachmentCount
+ &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments
+ { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4]
+ };
+
+ m_graphicsPipeline0 = makeGraphicsPipeline(vk, // const DeviceInterface& vk
+ vkDevice, // const VkDevice device
+ *m_pipelineLayout, // const VkPipelineLayout pipelineLayout
+ *m_vertexShaderModule, // const VkShaderModule vertexShaderModule
+ DE_NULL, // const VkShaderModule tessellationControlModule
+ DE_NULL, // const VkShaderModule tessellationEvalModule
+ DE_NULL, // const VkShaderModule geometryShaderModule
+ *m_fragmentShaderModule, // const VkShaderModule fragmentShaderModule
+ *m_renderPass, // const VkRenderPass renderPass
+ viewports, // const std::vector<VkViewport>& viewports
+ scissors, // const std::vector<VkRect2D>& scissors
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // const VkPrimitiveTopology topology
+ 0u, // const deUint32 subpass
+ 0u, // const deUint32 patchControlPoints
+ &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
+ DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
+ DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
+ DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
+ &colorBlendStateCreateInfo); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
+
+ m_graphicsPipeline1 = makeGraphicsPipeline(vk, // const DeviceInterface& vk
+ vkDevice, // const VkDevice device
+ *m_pipelineLayout, // const VkPipelineLayout pipelineLayout
+ *m_vertexShaderModule, // const VkShaderModule vertexShaderModule
+ DE_NULL, // const VkShaderModule tessellationControlModule
+ DE_NULL, // const VkShaderModule tessellationEvalModule
+ DE_NULL, // const VkShaderModule geometryShaderModule
+ *m_fragmentShaderModule, // const VkShaderModule fragmentShaderModule
+ *m_renderPass, // const VkRenderPass renderPass
+ viewports, // const std::vector<VkViewport>& viewports
+ scissors, // const std::vector<VkRect2D>& scissors
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // const VkPrimitiveTopology topology
+ 1u, // const deUint32 subpass
+ 0u, // const deUint32 patchControlPoints
+ &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
+ DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
+ DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
+ DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
+ &colorBlendStateCreateInfo); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
+
+ m_graphicsPipeline2 = makeGraphicsPipeline(vk, // const DeviceInterface& vk
+ vkDevice, // const VkDevice device
+ *m_pipelineLayout, // const VkPipelineLayout pipelineLayout
+ *m_vertexShaderModule, // const VkShaderModule vertexShaderModule
+ DE_NULL, // const VkShaderModule tessellationControlModule
+ DE_NULL, // const VkShaderModule tessellationEvalModule
+ DE_NULL, // const VkShaderModule geometryShaderModule
+ *m_fragmentShaderModule, // const VkShaderModule fragmentShaderModule
+ *m_renderPass, // const VkRenderPass renderPass
+ viewports, // const std::vector<VkViewport>& viewports
+ scissors, // const std::vector<VkRect2D>& scissors
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // const VkPrimitiveTopology topology
+ 2u, // const deUint32 subpass
+ 0u, // const deUint32 patchControlPoints
+ &vertexInputState, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
+ DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
+ DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
+ DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
+ &colorBlendStateCreateInfo); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
+
+ }
+
+ // Create command pool
+ m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
+
+ // Create command buffer
+ createCommandBuffer(vk, vkDevice);
+}
+
+void MultipleSubpassesMultipleCommandBuffersTestInstance::createCommandBuffer (const DeviceInterface& vk,
+ VkDevice vkDevice)
+{
+ const VkRenderPassBeginInfo renderPassBeginInfoA =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *m_renderPass, // VkRenderPass renderPass;
+ *m_framebufferA, // VkFramebuffer framebuffer;
+ makeRect2D(m_renderSize), // VkRect2D renderArea;
+ 0u, // uint32_t clearValueCount;
+ DE_NULL // const VkClearValue* pClearValues;
+ };
+ const VkRenderPassBeginInfo renderPassBeginInfoB =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *m_renderPass, // VkRenderPass renderPass;
+ *m_framebufferB, // VkFramebuffer framebuffer;
+ makeRect2D(m_renderSize), // VkRect2D renderArea;
+ 0u, // uint32_t clearValueCount;
+ DE_NULL // const VkClearValue* pClearValues;
+ };
+
+ m_cmdBufferA = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ m_cmdBufferB = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+
+ const VkClearRect clearRect =
+ {
+ { // VkRect2D rect;
+ { 0, 0, }, // VkOffset2D offset;
+ { kImageWidth, kImageHeight } // VkExtent2D extent;
+ },
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkClearAttachment clearAttachment =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t colorAttachment;
+ m_clearColor // VkClearValue clearValue;
+ };
+
+ VkDeviceSize vertexBufferOffset = 0u;
+
+ // Command Buffer A will set his own event but wait for the B's event before continuing to the next subpass.
+ beginCommandBuffer(vk, *m_cmdBufferA, 0u);
+ beginCommandBuffer(vk, *m_cmdBufferB, 0u);
+ vk.cmdBeginRenderPass(*m_cmdBufferA, &renderPassBeginInfoA, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindPipeline(*m_cmdBufferA, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline0);
+ vk.cmdBindVertexBuffers(*m_cmdBufferA, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
+ vk.cmdClearAttachments(*m_cmdBufferA, 1u, &clearAttachment, 1u, &clearRect);
+
+ vk.cmdBeginRenderPass(*m_cmdBufferB, &renderPassBeginInfoB, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindPipeline(*m_cmdBufferB, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline0);
+ vk.cmdClearAttachments(*m_cmdBufferB, 1u, &clearAttachment, 1u, &clearRect);
+ vk.cmdNextSubpass(*m_cmdBufferB, VK_SUBPASS_CONTENTS_INLINE);
+
+ vk.cmdNextSubpass(*m_cmdBufferA, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindPipeline(*m_cmdBufferA, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline1);
+ vk.cmdBindVertexBuffers(*m_cmdBufferA, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
+ vk.cmdDraw(*m_cmdBufferA, 4u, 1u, 0u, 0u);
+
+ vertexBufferOffset = 8 * sizeof(Vertex);
+ vk.cmdBindPipeline(*m_cmdBufferB, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline1);
+ vk.cmdBindVertexBuffers(*m_cmdBufferB, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
+ vk.cmdDraw(*m_cmdBufferB, 4u, 1u, 0u, 0u);
+ vk.cmdNextSubpass(*m_cmdBufferB, VK_SUBPASS_CONTENTS_INLINE);
+
+ vertexBufferOffset = 0u;
+ vk.cmdNextSubpass(*m_cmdBufferA, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindPipeline(*m_cmdBufferA, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline2);
+ vk.cmdBindVertexBuffers(*m_cmdBufferA, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
+ vk.cmdDraw(*m_cmdBufferA, 4u, 1u, 4u, 0u);
+
+ vertexBufferOffset = 8 * sizeof(Vertex);
+ vk.cmdBindPipeline(*m_cmdBufferB, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline2);
+ vk.cmdDraw(*m_cmdBufferB, 4u, 1u, 4u, 0u);
+ vk.cmdEndRenderPass(*m_cmdBufferB);
+ vk.cmdEndRenderPass(*m_cmdBufferA);
+ endCommandBuffer(vk, *m_cmdBufferA);
+ endCommandBuffer(vk, *m_cmdBufferB);
+}
+
+tcu::TestStatus MultipleSubpassesMultipleCommandBuffersTestInstance::iterate (void)
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
+
+ {
+ const Unique<VkFence> fence (createFence(vk, vkDevice));
+ std::vector<VkCommandBuffer> commandBuffers;
+ commandBuffers.emplace_back(m_cmdBufferA.get());
+ commandBuffers.emplace_back(m_cmdBufferB.get());
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
+ static_cast<deUint32>(commandBuffers.size()), // deUint32 commandBufferCount;
+ commandBuffers.data(), // const VkCommandBuffer* pCommandBuffers;
+ 0u, // deUint32 signalSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pSignalSemaphores;
+ };
+
+ VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
+ }
+
+ // XXX: Add code for image verification for both color attachments
+ {
+ // Colors to compare to.
+ const tcu::Vec4 red = {1.0f, 0.0f, 0.0f, 1.0f};
+ const tcu::Vec4 green = {0.0f, 1.0f, 0.0f, 1.0f};
+ const tcu::Vec4 blue = {0.0f, 0.0f, 1.0f, 1.0f};
+ const tcu::Vec4 yellow = {1.0f, 1.0f, 0.0f, 1.0f};
+
+ // Read result images.
+ de::MovePtr<tcu::TextureLevel> imagePixelsA = pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImageA, VK_FORMAT_R32G32B32A32_SFLOAT, m_renderSize);
+ de::MovePtr<tcu::TextureLevel> imagePixelsB = pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImageB, VK_FORMAT_R32G32B32A32_SFLOAT, m_renderSize);
+
+ // Verify pixel colors match.
+ const tcu::ConstPixelBufferAccess& imageAccessA = imagePixelsA->getAccess();
+ const tcu::ConstPixelBufferAccess& imageAccessB = imagePixelsB->getAccess();
+
+
+ tcu::TextureLevel referenceImageA(mapVkFormat(VK_FORMAT_R32G32B32A32_SFLOAT), m_renderSize.x(), m_renderSize.y());
+ tcu::TextureLevel referenceImageB(mapVkFormat(VK_FORMAT_R32G32B32A32_SFLOAT), m_renderSize.x(), m_renderSize.y());
+
+ tcu::clear(tcu::getSubregion(referenceImageA.getAccess(), 0u, 0u,
+ imageAccessA.getWidth() / 2, imageAccessA.getHeight()),
+ red);
+ tcu::clear(tcu::getSubregion(referenceImageA.getAccess(), imageAccessA.getWidth() / 2, 0u,
+ imageAccessA.getWidth() / 2, imageAccessA.getHeight()),
+ green);
+
+ if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", referenceImageA.getAccess(), imageAccessA, tcu::Vec4(0.02f), tcu::COMPARE_LOG_RESULT))
+ TCU_FAIL("[A] Rendered image is not correct");
+
+ tcu::clear(tcu::getSubregion(referenceImageB.getAccess(), 0u, 0u,
+ imageAccessB.getWidth() / 2, imageAccessB.getHeight()),
+ blue);
+ tcu::clear(tcu::getSubregion(referenceImageB.getAccess(), imageAccessB.getWidth() / 2, 0u,
+ imageAccessA.getWidth() / 2, imageAccessB.getHeight()),
+ yellow);
+
+ if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", referenceImageB.getAccess(), imageAccessB, tcu::Vec4(0.02f), tcu::COMPARE_LOG_RESULT))
+ TCU_FAIL("[B] Rendered image is not correct");
+
+ }
+
+ return tcu::TestStatus::pass("Pass");
+}
+} // anonymous
+
+tcu::TestCaseGroup* createRenderPassMultipleSubpassesMultipleCommandBuffersTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "multiple_subpasses_multiple_command_buffers", "Multiple subpasses multiple command buffers"));
+
+ testGroup->addChild(new MultipleSubpassesMultipleCommandBuffersTest(testCtx, "test", ""));
+
+ return testGroup.release();
+}
+
+} // renderpass
+} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff