| /*------------------------------------------------------------------------- |
| * Vulkan Conformance Tests |
| * ----------------------------- |
| * |
| * Copyright (c) 2020 Google Inc. |
| * 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 |
| * \brief Tests for multiple color or depth clears within a render pass |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktDrawMultipleClearsWithinRenderPass.hpp" |
| |
| #include "vktTestGroupUtil.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vktDrawCreateInfoUtil.hpp" |
| #include "vktDrawBufferObjectUtil.hpp" |
| #include "vktDrawImageObjectUtil.hpp" |
| #include "vkPrograms.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkQueryUtil.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuCommandLine.hpp" |
| #include "vktDrawTestCaseUtil.hpp" |
| |
| #include "deStringUtil.hpp" |
| |
| #include <cmath> |
| #include <vector> |
| #include <string> |
| #include <sstream> |
| |
| namespace vkt |
| { |
| namespace Draw |
| { |
| namespace |
| { |
| using namespace vk; |
| using tcu::Vec4; |
| using de::SharedPtr; |
| using std::string; |
| using std::abs; |
| using std::vector; |
| using std::ostringstream; |
| |
| const deUint32 WIDTH = 400; |
| const deUint32 HEIGHT = 300; |
| |
| enum struct Topology |
| { |
| TRIANGLE_STRIP = 0, |
| TRIANGLES, |
| TRIANGLE |
| }; |
| |
| const Topology topologiesToTest[] = |
| { |
| Topology::TRIANGLE_STRIP, |
| Topology::TRIANGLES, |
| Topology::TRIANGLE |
| }; |
| |
| struct FormatPair |
| { |
| VkFormat colorFormat; |
| VkFormat depthFormat; |
| }; |
| |
| const FormatPair formatsToTest[] = |
| { |
| { VK_FORMAT_R8G8B8A8_UNORM , VK_FORMAT_UNDEFINED }, |
| { VK_FORMAT_R8G8B8A8_SNORM , VK_FORMAT_UNDEFINED }, |
| { VK_FORMAT_UNDEFINED , VK_FORMAT_D32_SFLOAT }, |
| { VK_FORMAT_UNDEFINED , VK_FORMAT_D16_UNORM }, |
| { VK_FORMAT_R8G8B8A8_UNORM , VK_FORMAT_D32_SFLOAT }, |
| { VK_FORMAT_R8G8B8A8_UNORM , VK_FORMAT_D16_UNORM }, |
| { VK_FORMAT_R8G8B8A8_SNORM , VK_FORMAT_D32_SFLOAT }, |
| { VK_FORMAT_R8G8B8A8_SNORM , VK_FORMAT_D16_UNORM }, |
| }; |
| |
| const Vec4 verticesTriangleStrip[] = |
| { |
| Vec4(-1.0f, -1.0f, 0.0f, 1.0f), // 0 -- 2 |
| Vec4(-1.0f, 1.0f, 0.0f, 1.0f), // | / | |
| Vec4( 1.0f, -1.0f, 0.0f, 1.0f), // | / | |
| Vec4( 1.0f, 1.0f, 0.0f, 1.0f) // 1 -- 3 |
| }; |
| const Vec4 verticesTriangles[] = |
| { |
| Vec4(-1.0f, -1.0f, 0.0f, 1.0f), // 0 - 1 |
| Vec4(-1.0f, 1.0f, 0.0f, 1.0f), // | / |
| Vec4( 1.0f, -1.0f, 0.0f, 1.0f), // 2 |
| Vec4( 1.0f, -1.0f, 0.0f, 1.0f), // 4 |
| Vec4(-1.0f, 1.0f, 0.0f, 1.0f), // / | |
| Vec4( 1.0f, 1.0f, 0.0f, 1.0f) // 3 - 5 |
| }; |
| const Vec4 verticesBigTriangle[] = |
| { |
| Vec4(-1.0f, -1.0f, 0.0f, 1.0f), // 0 - 2 |
| Vec4(-1.0f, 3.0f, 0.0f, 1.0f), // | / |
| Vec4( 3.0f, -1.0f, 0.0f, 1.0f), // 1 |
| }; |
| |
| const deUint32 TOPOLOGY_MAX_VERTICES_COUNT = 6; |
| const deUint32 TEST_MAX_STEPS_COUNT = 3; |
| |
| struct Vertices |
| { |
| const char* testNameSuffix; |
| VkPrimitiveTopology topology; |
| deUint32 verticesCount; |
| const Vec4* vertices; |
| }; |
| |
| const Vertices verticesByTopology[] = |
| { |
| { |
| "_triangle_strip", |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, |
| DE_LENGTH_OF_ARRAY(verticesTriangleStrip), |
| verticesTriangleStrip |
| }, |
| { |
| "_triangles", |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, |
| DE_LENGTH_OF_ARRAY(verticesTriangles), |
| verticesTriangles |
| }, |
| { |
| "_big_triangle", |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, |
| DE_LENGTH_OF_ARRAY(verticesBigTriangle), |
| verticesBigTriangle |
| } |
| }; |
| |
| enum struct ClearOp |
| { |
| LOAD = 0, |
| DRAW, |
| CLEAR |
| }; |
| |
| struct ClearStep |
| { |
| ClearOp clearOp; |
| Vec4 color; |
| float depth; |
| }; |
| |
| struct TestParams |
| { |
| VkFormat colorFormat; |
| VkFormat depthFormat; |
| Topology topology; |
| Vec4 expectedColor; |
| float colorEpsilon; |
| float expectedDepth; |
| float depthEpsilon; |
| deUint32 repeatCount; |
| bool enableBlend; |
| const SharedGroupParams groupParams; |
| vector<ClearStep> steps; |
| }; |
| |
| class MultipleClearsTest : public TestInstance |
| { |
| public: |
| MultipleClearsTest (Context& context, const TestParams& params); |
| virtual tcu::TestStatus iterate (void); |
| |
| private: |
| void preRenderCommands (VkCommandBuffer cmdBuffer) const; |
| void beginLegacyRender (VkCommandBuffer cmdBuffer) const; |
| void drawCommands (VkCommandBuffer cmdBuffer) const; |
| |
| #ifndef CTS_USES_VULKANSC |
| void beginSecondaryCmdBuffer (VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags = 0u) const; |
| void beginDynamicRender (VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags = 0u) const; |
| #endif // CTS_USES_VULKANSC |
| |
| SharedPtr<Image> m_colorTargetImage; |
| SharedPtr<Image> m_depthTargetImage; |
| Move<VkImageView> m_colorTargetView; |
| Move<VkImageView> m_depthTargetView; |
| SharedPtr<Buffer> m_vertexBuffer; |
| Move<VkRenderPass> m_renderPass; |
| Move<VkFramebuffer> m_framebuffer; |
| Move<VkPipelineLayout> m_pipelineLayout; |
| Move<VkPipeline> m_pipeline; |
| |
| const TestParams m_params; |
| Vec4 m_vertices[TOPOLOGY_MAX_VERTICES_COUNT * TEST_MAX_STEPS_COUNT]; |
| }; |
| |
| MultipleClearsTest::MultipleClearsTest (Context &context, const TestParams& params) |
| : TestInstance(context) |
| , m_params(params) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| const bool hasColor = m_params.colorFormat != VK_FORMAT_UNDEFINED; |
| const bool hasDepth = m_params.depthFormat != VK_FORMAT_UNDEFINED; |
| |
| DescriptorSetLayoutBuilder descriptorSetLayoutBuilder; |
| // Vertex data |
| const auto& vertexData = verticesByTopology[(size_t)m_params.topology]; |
| { |
| DE_ASSERT(vertexData.verticesCount <= TOPOLOGY_MAX_VERTICES_COUNT); |
| const size_t verticesCount = vertexData.verticesCount; |
| const VkDeviceSize dataSize = verticesCount * sizeof(Vec4); |
| const VkDeviceSize totalDataSize = m_params.steps.size() * dataSize; |
| DE_ASSERT(totalDataSize <= sizeof(m_vertices)); |
| |
| for(size_t i = 0; i < m_params.steps.size(); ++i) |
| { |
| const size_t start = i * verticesCount; |
| deMemcpy(&m_vertices[start], vertexData.vertices, static_cast<size_t>(dataSize)); |
| for(size_t j = 0; j < verticesCount; ++j) |
| m_vertices[start + j][2] = m_params.steps[i].depth; |
| } |
| m_vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(totalDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), |
| m_context.getDefaultAllocator(), MemoryRequirement::HostVisible); |
| deMemcpy(m_vertexBuffer->getBoundMemory().getHostPtr(), m_vertices, static_cast<std::size_t>(totalDataSize)); |
| flushMappedMemoryRange(vk, device, m_vertexBuffer->getBoundMemory().getMemory(), m_vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE); |
| } |
| |
| if (hasColor) |
| { |
| const VkImageUsageFlags targetImageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| const ImageCreateInfo targetImageCreateInfo (VK_IMAGE_TYPE_2D, m_params.colorFormat, { WIDTH, HEIGHT, 1u }, 1u, 1u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, targetImageUsageFlags); |
| m_colorTargetImage = Image::createAndAlloc(vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), queueFamilyIndex); |
| const ImageViewCreateInfo colorTargetViewInfo (m_colorTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_params.colorFormat); |
| m_colorTargetView = createImageView(vk, device, &colorTargetViewInfo); |
| } |
| |
| if (hasDepth) |
| { |
| const VkImageUsageFlags depthImageUsageFlags = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| const ImageCreateInfo depthImageCreateInfo (VK_IMAGE_TYPE_2D, m_params.depthFormat, { WIDTH, HEIGHT, 1u }, 1u, 1u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, depthImageUsageFlags); |
| m_depthTargetImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator(), queueFamilyIndex); |
| const ImageViewCreateInfo depthTargetViewInfo (m_depthTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_params.depthFormat); |
| m_depthTargetView = createImageView(vk, device, &depthTargetViewInfo); |
| } |
| |
| // Render pass |
| if (!m_params.groupParams->useDynamicRendering) |
| { |
| RenderPassCreateInfo renderPassCreateInfo; |
| if (hasColor) |
| { |
| renderPassCreateInfo.addAttachment(AttachmentDescription( |
| m_params.colorFormat, // format |
| VK_SAMPLE_COUNT_1_BIT, // samples |
| VK_ATTACHMENT_LOAD_OP_LOAD, // loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // storeOp |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLayout |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)); // finalLayout |
| } |
| if (hasDepth) |
| { |
| renderPassCreateInfo.addAttachment(AttachmentDescription( |
| m_params.depthFormat, // format |
| VK_SAMPLE_COUNT_1_BIT, // samples |
| VK_ATTACHMENT_LOAD_OP_LOAD, // loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // storeOp |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp |
| VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLayout |
| VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout |
| } |
| const VkAttachmentReference colorAttachmentReference = hasColor ? makeAttachmentReference(0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) : AttachmentReference(); |
| const VkAttachmentReference depthAttachmentReference = hasDepth ? makeAttachmentReference(hasColor ? 1u : 0u, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) : AttachmentReference(); |
| renderPassCreateInfo.addSubpass(SubpassDescription( |
| VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint |
| (VkSubpassDescriptionFlags)0, // flags |
| 0u, // inputAttachmentCount |
| DE_NULL, // inputAttachments |
| hasColor ? 1 : 0, // colorAttachmentCount |
| hasColor ? &colorAttachmentReference : DE_NULL, // colorAttachments |
| DE_NULL, // resolveAttachments |
| depthAttachmentReference, // depthStencilAttachment |
| 0u, // preserveAttachmentCount |
| DE_NULL)); // preserveAttachments |
| m_renderPass = createRenderPass(vk, device, &renderPassCreateInfo); |
| |
| std::vector<VkImageView> attachments; |
| if (hasColor) |
| attachments.push_back(*m_colorTargetView); |
| if (hasDepth) |
| attachments.push_back(*m_depthTargetView); |
| const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1); |
| m_framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo); |
| } |
| |
| // Vertex input |
| const VkVertexInputBindingDescription vertexInputBindingDescription = |
| { |
| 0u, // uint32_t binding; |
| sizeof(Vec4), // uint32_t stride; |
| VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate; |
| }; |
| |
| const VkVertexInputAttributeDescription vertexInputAttributeDescription = |
| { |
| 0u, // uint32_t location; |
| 0u, // uint32_t binding; |
| VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format; |
| 0u // uint32_t offset; |
| }; |
| |
| const PipelineCreateInfo::VertexInputState vertexInputState = PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription, |
| 1, &vertexInputAttributeDescription); |
| |
| // Graphics pipeline |
| const Unique<VkShaderModule> vertexModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0)); |
| const Unique<VkShaderModule> fragmentModule (createShaderModule(vk, device, m_context.getBinaryCollection().get(hasColor ? "frag" : "frag_depthonly"), 0)); |
| |
| const VkPushConstantRange pcRange = vk::VkPushConstantRange { VkShaderStageFlagBits::VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(ClearStep::color) }; |
| const PipelineLayoutCreateInfo pipelineLayoutCreateInfo (0u, DE_NULL, 1u, &pcRange); |
| m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo); |
| |
| const VkRect2D scissor = makeRect2D(WIDTH, HEIGHT); |
| const VkViewport viewport = makeViewport(WIDTH, HEIGHT); |
| |
| const auto vkCbAttachmentState = makePipelineColorBlendAttachmentState( |
| m_params.enableBlend ? VK_TRUE : VK_FALSE, // VkBool32 blendEnable |
| VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor |
| VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstColorBlendFactor |
| VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp |
| VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor |
| VK_BLEND_FACTOR_ONE, // 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); |
| PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0); |
| pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vertexModule, "main", VK_SHADER_STAGE_VERTEX_BIT)); |
| pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fragmentModule, "main", VK_SHADER_STAGE_FRAGMENT_BIT)); |
| pipelineCreateInfo.addState (PipelineCreateInfo::VertexInputState (vertexInputState)); |
| pipelineCreateInfo.addState (PipelineCreateInfo::InputAssemblerState(vertexData.topology)); |
| pipelineCreateInfo.addState (PipelineCreateInfo::ColorBlendState (1, &vkCbAttachmentState)); |
| pipelineCreateInfo.addState (PipelineCreateInfo::ViewportState (1, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor))); |
| pipelineCreateInfo.addState (PipelineCreateInfo::DepthStencilState (hasDepth, hasDepth, VK_COMPARE_OP_ALWAYS, VK_FALSE, VK_FALSE)); |
| pipelineCreateInfo.addState (PipelineCreateInfo::RasterizerState ()); |
| pipelineCreateInfo.addState (PipelineCreateInfo::MultiSampleState ()); |
| |
| #ifndef CTS_USES_VULKANSC |
| vk::VkPipelineRenderingCreateInfoKHR renderingCreateInfo |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, |
| DE_NULL, |
| 0u, |
| hasColor, |
| (hasColor ? &m_params.colorFormat : DE_NULL), |
| m_params.depthFormat, |
| m_params.depthFormat |
| }; |
| |
| if (m_params.groupParams->useDynamicRendering) |
| pipelineCreateInfo.pNext = &renderingCreateInfo; |
| #endif // CTS_USES_VULKANSC |
| |
| m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo); |
| } |
| |
| void MultipleClearsTest::preRenderCommands(VkCommandBuffer cmdBuffer) const |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| if (m_params.colorFormat) |
| initialTransitionColor2DImage(vk, cmdBuffer, m_colorTargetImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); |
| if (m_params.depthFormat) |
| initialTransitionDepth2DImage(vk, cmdBuffer, m_depthTargetImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT); |
| } |
| |
| void MultipleClearsTest::beginLegacyRender(VkCommandBuffer cmdBuffer) const |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkRect2D renderArea = makeRect2D(0, 0, WIDTH, HEIGHT); |
| |
| if (!m_params.steps.empty() && m_params.steps[0].clearOp == ClearOp::LOAD) |
| beginRenderPass(vk, cmdBuffer, *m_renderPass, *m_framebuffer, renderArea, m_params.steps[0].color, m_params.steps[0].depth, 0); |
| else |
| beginRenderPass(vk, cmdBuffer, *m_renderPass, *m_framebuffer, renderArea); |
| } |
| |
| void MultipleClearsTest::drawCommands(vk::VkCommandBuffer cmdBuffer) const |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| |
| vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline); |
| { |
| const VkDeviceSize offset = 0; |
| const VkBuffer buffer = m_vertexBuffer->object(); |
| vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &buffer, &offset); |
| } |
| |
| for (deUint32 i = 0; i < m_params.repeatCount; ++i) |
| for (size_t stepIndex = 0; stepIndex < m_params.steps.size(); ++stepIndex) |
| { |
| const auto& step = m_params.steps[stepIndex]; |
| |
| // ClearOp::LOAD only supported for first step |
| DE_ASSERT(stepIndex == 0 || step.clearOp != ClearOp::LOAD); |
| |
| const Vec4& color = step.color; |
| const float depth = step.depth; |
| |
| switch(step.clearOp) |
| { |
| case ClearOp::LOAD: |
| break; |
| case ClearOp::DRAW: |
| { |
| const auto& vertexData = verticesByTopology[(size_t)m_params.topology]; |
| const deUint32 verticesCount = vertexData.verticesCount; |
| vk.cmdPushConstants(cmdBuffer, *m_pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(color), color.getPtr()); |
| vk.cmdDraw(cmdBuffer, verticesCount, 1, static_cast<deUint32>(verticesCount * stepIndex), 0); |
| } |
| break; |
| case ClearOp::CLEAR: |
| { |
| vector<VkClearAttachment> clearAttachments; |
| if (m_params.colorFormat != VK_FORMAT_UNDEFINED) |
| { |
| const VkClearAttachment clearAttachment |
| { |
| VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask |
| static_cast<deUint32>(clearAttachments.size()), // uint32_t colorAttachment |
| makeClearValueColor(color) // VkClearValue clearValue |
| }; |
| clearAttachments.push_back(clearAttachment); |
| } |
| if (m_params.depthFormat != VK_FORMAT_UNDEFINED) |
| { |
| const VkClearAttachment clearAttachment |
| { |
| VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask |
| static_cast<deUint32>(clearAttachments.size()), // uint32_t colorAttachment |
| makeClearValueDepthStencil(depth, 0) // VkClearValue clearValue |
| }; |
| clearAttachments.push_back(clearAttachment); |
| } |
| const VkClearRect clearRect |
| { |
| makeRect2D(WIDTH, HEIGHT), // VkRect2D rect |
| 0, // uint32_t baseArrayLayer |
| 1 // uint32_t layerCount |
| }; |
| vk.cmdClearAttachments(cmdBuffer, static_cast<deUint32>(clearAttachments.size()), clearAttachments.data(), 1, &clearRect); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| |
| #ifndef CTS_USES_VULKANSC |
| void MultipleClearsTest::beginSecondaryCmdBuffer(VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags) const |
| { |
| VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo |
| { |
| VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| renderingFlags, // VkRenderingFlagsKHR flags; |
| 0u, // uint32_t viewMask; |
| (m_params.colorFormat != VK_FORMAT_UNDEFINED), // uint32_t colorAttachmentCount; |
| &m_params.colorFormat, // const VkFormat* pColorAttachmentFormats; |
| m_params.depthFormat, // VkFormat depthAttachmentFormat; |
| VK_FORMAT_UNDEFINED, // VkFormat stencilAttachmentFormat; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; |
| }; |
| |
| const VkCommandBufferInheritanceInfo bufferInheritanceInfo = initVulkanStructure(&inheritanceRenderingInfo); |
| |
| VkCommandBufferUsageFlags usageFlags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; |
| if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass) |
| usageFlags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; |
| |
| const VkCommandBufferBeginInfo commandBufBeginParams |
| { |
| VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| usageFlags, // VkCommandBufferUsageFlags flags; |
| &bufferInheritanceInfo |
| }; |
| |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &commandBufBeginParams)); |
| } |
| |
| void MultipleClearsTest::beginDynamicRender(VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags) const |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkRect2D renderArea = makeRect2D(0, 0, WIDTH, HEIGHT); |
| |
| VkClearValue clearColorValue = makeClearValueColor(tcu::Vec4(0.0f)); |
| VkClearValue clearDepthValue = makeClearValueDepthStencil(0.0f, 0u); |
| if (!m_params.steps.empty() && m_params.steps[0].clearOp == ClearOp::LOAD) |
| { |
| clearColorValue = makeClearValueColor(m_params.steps[0].color); |
| clearDepthValue = makeClearValueDepthStencil(m_params.steps[0].depth, 0u); |
| } |
| |
| vk::VkRenderingAttachmentInfoKHR colorAttachment |
| { |
| vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| *m_colorTargetView, // VkImageView imageView; |
| vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout; |
| vk::VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode; |
| DE_NULL, // VkImageView resolveImageView; |
| vk::VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout; |
| vk::VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp; |
| vk::VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; |
| clearColorValue // VkClearValue clearValue; |
| }; |
| |
| vk::VkRenderingAttachmentInfoKHR depthAttachment |
| { |
| vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| *m_depthTargetView, // VkImageView imageView; |
| vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout; |
| vk::VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode; |
| DE_NULL, // VkImageView resolveImageView; |
| vk::VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout; |
| vk::VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp; |
| vk::VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; |
| clearDepthValue // VkClearValue clearValue; |
| }; |
| |
| const bool hasColor = m_params.colorFormat != VK_FORMAT_UNDEFINED; |
| const bool hasDepth = m_params.depthFormat != VK_FORMAT_UNDEFINED; |
| |
| vk::VkRenderingInfoKHR renderingInfo |
| { |
| vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR, |
| DE_NULL, |
| renderingFlags, // VkRenderingFlagsKHR flags; |
| renderArea, // VkRect2D renderArea; |
| 1u, // deUint32 layerCount; |
| 0u, // deUint32 viewMask; |
| hasColor, // deUint32 colorAttachmentCount; |
| (hasColor ? &colorAttachment : DE_NULL), // const VkRenderingAttachmentInfoKHR* pColorAttachments; |
| (hasDepth ? &depthAttachment : DE_NULL), // const VkRenderingAttachmentInfoKHR* pDepthAttachment; |
| DE_NULL, // const VkRenderingAttachmentInfoKHR* pStencilAttachment; |
| }; |
| |
| vk.cmdBeginRendering(cmdBuffer, &renderingInfo); |
| } |
| #endif // CTS_USES_VULKANSC |
| |
| tcu::TestStatus MultipleClearsTest::iterate (void) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| const VkQueue queue = m_context.getUniversalQueue(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| |
| const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex); |
| const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, &cmdPoolCreateInfo)); |
| const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); |
| Move<VkCommandBuffer> secCmdBuffer; |
| |
| const bool hasColor = m_params.colorFormat != VK_FORMAT_UNDEFINED; |
| const bool hasDepth = m_params.depthFormat != VK_FORMAT_UNDEFINED; |
| |
| #ifndef CTS_USES_VULKANSC |
| if (m_params.groupParams->useSecondaryCmdBuffer) |
| { |
| secCmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| |
| // record secondary command buffer |
| if (m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass) |
| { |
| beginSecondaryCmdBuffer(*secCmdBuffer, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT); |
| beginDynamicRender(*secCmdBuffer); |
| } |
| else |
| beginSecondaryCmdBuffer(*secCmdBuffer); |
| |
| drawCommands(*secCmdBuffer); |
| |
| if (m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass) |
| endRendering(vk, *secCmdBuffer); |
| |
| endCommandBuffer(vk, *secCmdBuffer); |
| |
| // record primary command buffer |
| beginCommandBuffer(vk, *cmdBuffer, 0u); |
| preRenderCommands(*cmdBuffer); |
| |
| if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass) |
| beginDynamicRender(*cmdBuffer, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); |
| |
| vk.cmdExecuteCommands(*cmdBuffer, 1u, &*secCmdBuffer); |
| |
| if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass) |
| endRendering(vk, *cmdBuffer); |
| } |
| else if (m_params.groupParams->useDynamicRendering) |
| { |
| beginCommandBuffer(vk, *cmdBuffer); |
| preRenderCommands(*cmdBuffer); |
| beginDynamicRender(*cmdBuffer); |
| drawCommands(*cmdBuffer); |
| endRendering(vk, *cmdBuffer); |
| } |
| #endif // CTS_USES_VULKANSC |
| |
| if (!m_params.groupParams->useDynamicRendering) |
| { |
| beginCommandBuffer(vk, *cmdBuffer); |
| preRenderCommands(*cmdBuffer); |
| beginLegacyRender(*cmdBuffer); |
| drawCommands(*cmdBuffer); |
| endRenderPass(vk, *cmdBuffer); |
| } |
| |
| if (hasDepth) |
| { |
| const VkMemoryBarrier memBarrier = { VK_STRUCTURE_TYPE_MEMORY_BARRIER, DE_NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT }; |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL); |
| } |
| if (hasColor) |
| { |
| const VkMemoryBarrier memBarrier = { VK_STRUCTURE_TYPE_MEMORY_BARRIER, DE_NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT }; |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL); |
| } |
| |
| if (hasColor) |
| transition2DImage(vk, *cmdBuffer, m_colorTargetImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_HOST_BIT); |
| if (hasDepth) |
| transition2DImage(vk, *cmdBuffer, m_depthTargetImage->object(), VK_IMAGE_ASPECT_DEPTH_BIT, |
| VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, |
| VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_HOST_BIT); |
| |
| endCommandBuffer(vk, *cmdBuffer); |
| submitCommandsAndWait(vk, device, queue, *cmdBuffer); |
| |
| VK_CHECK(vk.queueWaitIdle(queue)); |
| |
| if (hasColor) |
| { |
| const auto resultImage = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, { 0, 0, 0 }, WIDTH, HEIGHT, VK_IMAGE_ASPECT_COLOR_BIT); |
| |
| #ifdef CTS_USES_VULKANSC |
| if (m_context.getTestContext().getCommandLine().isSubProcess()) |
| #endif // CTS_USES_VULKANSC |
| { |
| for(int z = 0; z < resultImage.getDepth(); ++z) |
| for(int y = 0; y < resultImage.getHeight(); ++y) |
| for(int x = 0; x < resultImage.getWidth(); ++x) |
| { |
| const Vec4 difference = m_params.expectedColor - resultImage.getPixel(x,y,z); |
| if (abs(difference.x()) >= m_params.colorEpsilon || abs(difference.y()) >= m_params.colorEpsilon || abs(difference.z()) >= m_params.colorEpsilon) |
| { |
| ostringstream msg; |
| msg << "Color value mismatch, expected: " << m_params.expectedColor << ", got: " << resultImage.getPixel(x,y,z) << " at " << "(" << x << ", " << y << ", " << z << ")"; |
| return tcu::TestStatus::fail(msg.str()); |
| } |
| } |
| } |
| } |
| if (hasDepth) |
| { |
| const auto resultImage = m_depthTargetImage->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, { 0, 0, 0 }, WIDTH, HEIGHT, VK_IMAGE_ASPECT_DEPTH_BIT); |
| |
| #ifdef CTS_USES_VULKANSC |
| if (m_context.getTestContext().getCommandLine().isSubProcess()) |
| #endif // CTS_USES_VULKANSC |
| { |
| for(int z = 0; z < resultImage.getDepth(); ++z) |
| for(int y = 0; y < resultImage.getHeight(); ++y) |
| for(int x = 0; x < resultImage.getWidth(); ++x) |
| { |
| const float difference = m_params.expectedDepth - resultImage.getPixDepth(x,y,z); |
| if (abs(difference) >= m_params.depthEpsilon) |
| { |
| ostringstream msg; |
| msg << "Depth value mismatch, expected: " << m_params.expectedDepth << ", got: " << resultImage.getPixDepth(x,y,z) << " at " << "(" << x << ", " << y << ", " << z << ")"; |
| return tcu::TestStatus::fail(msg.str()); |
| } |
| } |
| } |
| } |
| return tcu::TestStatus::pass("Pass"); |
| } |
| |
| class MultipleClearsWithinRenderPassTest : public TestCase |
| { |
| public: |
| MultipleClearsWithinRenderPassTest (tcu::TestContext& testCtx, const string& name, const string& description, const TestParams& params) |
| : TestCase(testCtx, name, description) |
| , m_params(params) |
| { |
| DE_ASSERT(m_params.steps.size() <= static_cast<size_t>(TEST_MAX_STEPS_COUNT)); |
| } |
| |
| virtual void initPrograms (SourceCollections& programCollection) const |
| { |
| { |
| ostringstream src; |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" |
| << "\n" |
| << "layout(location = 0) in vec4 in_position;\n" |
| << "\n" |
| << "out gl_PerVertex {\n" |
| << " vec4 gl_Position;\n" |
| << "};\n" |
| << "\n" |
| << "void main(void)\n" |
| << "{\n" |
| << " gl_Position = in_position;\n" |
| << "}\n"; |
| programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); |
| } |
| { |
| ostringstream src; |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" |
| << "\n" |
| << "layout(push_constant) uniform Color { vec4 color; } u_color;\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "\n" |
| << "void main(void)\n" |
| << "{\n" |
| << " out_color = u_color.color;\n" |
| << "}\n"; |
| programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); |
| } |
| { |
| ostringstream src; |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" |
| << "\n" |
| << "layout(push_constant) uniform Color { vec4 color; } u_color;\n" |
| << "\n" |
| << "void main(void)\n" |
| << "{\n" |
| << "}\n"; |
| programCollection.glslSources.add("frag_depthonly") << glu::FragmentSource(src.str()); |
| } |
| } |
| |
| virtual void checkSupport (Context& context) const |
| { |
| VkImageFormatProperties imageFormatProperties; |
| const auto& vki = context.getInstanceInterface(); |
| const auto& vkd = context.getPhysicalDevice(); |
| if (m_params.colorFormat != VK_FORMAT_UNDEFINED) |
| { |
| const auto colorUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| if (vki.getPhysicalDeviceImageFormatProperties(vkd, m_params.colorFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, colorUsage, 0u, &imageFormatProperties) != VK_SUCCESS) |
| TCU_THROW(NotSupportedError, "Color format not supported"); |
| } |
| if (m_params.depthFormat != VK_FORMAT_UNDEFINED) |
| { |
| const auto depthUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| if (vki.getPhysicalDeviceImageFormatProperties(vkd, m_params.depthFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, depthUsage, 0u, &imageFormatProperties) != VK_SUCCESS) |
| TCU_THROW(NotSupportedError, "Depth format not supported"); |
| } |
| |
| if (m_params.groupParams->useDynamicRendering) |
| context.requireDeviceFunctionality("VK_KHR_dynamic_rendering"); |
| } |
| |
| virtual TestInstance* createInstance (Context& context) const |
| { |
| return new MultipleClearsTest(context, m_params); |
| } |
| |
| private: |
| const TestParams m_params; |
| }; |
| |
| } // anonymous |
| |
| MultipleClearsWithinRenderPassTests::MultipleClearsWithinRenderPassTests (tcu::TestContext &testCtx, const SharedGroupParams groupParams) |
| : TestCaseGroup (testCtx, "multiple_clears_within_render_pass", "Tests for multiple clears within render pass") |
| , m_groupParams (groupParams) |
| { |
| } |
| |
| MultipleClearsWithinRenderPassTests::~MultipleClearsWithinRenderPassTests () |
| { |
| } |
| |
| void MultipleClearsWithinRenderPassTests::init () |
| { |
| for(const auto &formatPair : formatsToTest) |
| { |
| ostringstream formatSuffix; |
| if (formatPair.colorFormat != VK_FORMAT_UNDEFINED) |
| formatSuffix << "_c" << de::toLower(string(getFormatName(formatPair.colorFormat)).substr(9)); |
| if (formatPair.depthFormat != VK_FORMAT_UNDEFINED) |
| formatSuffix << "_d" << de::toLower(string(getFormatName(formatPair.depthFormat)).substr(9)); |
| for(const auto &topology : topologiesToTest) |
| { |
| // reduce number of tests for dynamic rendering cases where secondary command buffer is used |
| if (m_groupParams->useSecondaryCmdBuffer && (topology != Topology::TRIANGLE_STRIP)) |
| continue; |
| |
| const string testNameSuffix = formatSuffix.str() + verticesByTopology[(deUint32)topology].testNameSuffix; |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat colorFormat; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 0.5f, 0.5f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| true, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::LOAD , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.7f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::DRAW , Vec4(0.0f, 0.0f, 1.0f, 0.5f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "load_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: load, clear, draw", params)); |
| } |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat format; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 0.5f, 0.5f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| true, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::DRAW , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.7f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::DRAW , Vec4(0.0f, 0.0f, 1.0f, 0.5f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "draw_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: draw, clear, draw", params)); |
| } |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat format; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 0.5f, 0.5f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| true, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::CLEAR , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.7f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::DRAW , Vec4(0.0f, 0.0f, 1.0f, 0.5f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "clear_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: clear, clear, draw", params)); |
| } |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat format; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 1.0f, 0.0f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| false, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::LOAD , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "load_clear" + testNameSuffix, "Multiple clears within same render pass, methods: load, clear", params)); |
| } |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat format; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 1.0f, 0.0f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| false, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::DRAW , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "draw_clear" + testNameSuffix, "Multiple clears within same render pass, methods: draw, clear", params)); |
| } |
| { |
| const TestParams params |
| { |
| formatPair.colorFormat, // VkFormat format; |
| formatPair.depthFormat, // VkFormat depthFormat; |
| topology, // Topology topology; |
| Vec4(0.0f, 1.0f, 0.0f, 1.0f), // Vec4 expectedColor; |
| 0.01f, // float colorEpsilon; |
| 0.9f, // float expectedDepth; |
| 0.01f, // float depthEpsilon; |
| 1u, // deUint32 repeatCount; |
| false, // bool enableBlend; |
| m_groupParams, // SharedGroupParams groupParams; |
| { // vector<ClearStep> steps; |
| { ClearOp::CLEAR , Vec4(1.0f, 0.0f, 0.0f, 1.0f) , 0.3f }, |
| { ClearOp::CLEAR , Vec4(0.0f, 1.0f, 0.0f, 1.0f) , 0.9f } |
| } |
| }; |
| addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "clear_clear" + testNameSuffix, "Multiple clears within same render pass, methods: clear, clear", params)); |
| } |
| } |
| } |
| } |
| } // Draw |
| } // vkt |
