| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2020 The Khronos Group Inc. |
| * Copyright (c) 2020 ARM Ltd. |
| * |
| * 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 VK_ARM_rasterization_order_attachment_access tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "deDefs.hpp" |
| #include "deSharedPtr.hpp" |
| #include "deUniquePtr.hpp" |
| #include "tcuCommandLine.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuResource.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuStringTemplate.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkDefs.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkObjUtil.hpp" |
| #include "vkPlatform.hpp" |
| #include "vkPrograms.hpp" |
| #include "vkQueryUtil.hpp" |
| #include "vkRef.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vktRasterizationOrderAttachmentAccessTests.hpp" |
| #include "vktRasterizationTests.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "vktTestCase.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vktTestGroupUtil.hpp" |
| |
| using namespace vk; |
| using namespace std; |
| using namespace vkt; |
| using de::UniquePtr; |
| using de::MovePtr; |
| using de::SharedPtr; |
| |
| namespace vkt |
| { |
| |
| namespace rasterization |
| { |
| |
| namespace |
| { |
| |
| class AttachmentAccessOrderTestCase : public TestCase |
| { |
| public: |
| enum |
| { |
| ELEM_NUM = 6 |
| }; |
| |
| AttachmentAccessOrderTestCase( tcu::TestContext& context, const std::string& name, const std::string& description, |
| bool explicitSync, bool overlapDraws, bool overlapPrimitives, bool overlapInstances, |
| VkSampleCountFlagBits sampleCount, deUint32 inputAttachmentNum, bool integerFormat); |
| virtual ~AttachmentAccessOrderTestCase (void); |
| |
| virtual void initPrograms (SourceCollections& programCollection) const; |
| virtual TestInstance* createInstance (Context& context) const; |
| virtual void checkSupport (Context& context) const; |
| |
| virtual deUint32 getInputAttachmentNum() const = 0; |
| virtual deUint32 getColorAttachmentNum() const = 0; |
| virtual bool hasDepthStencil() const = 0; |
| virtual VkImageAspectFlagBits getDSAspect() const = 0; |
| |
| |
| |
| |
| deUint32 m_inputAttachmentNum; |
| const bool m_explicitSync; |
| const bool m_overlapDraws; |
| const bool m_overlapPrimitives; |
| const bool m_overlapInstances; |
| VkSampleCountFlagBits m_sampleCount; |
| const deUint32 m_sampleNum; |
| const bool m_integerFormat; |
| static deUint32 getSampleNum(VkSampleCountFlagBits sampleCount); |
| |
| VkFormat getColorFormat() const |
| { |
| return m_integerFormat ? VK_FORMAT_R32G32_UINT : VK_FORMAT_R32G32_SFLOAT; |
| } |
| VkFormat getDSFormat() const |
| { |
| return VK_FORMAT_D32_SFLOAT_S8_UINT; |
| } |
| |
| VkPipelineColorBlendStateCreateFlags getBlendStateFlags() const |
| { |
| return m_explicitSync ? 0 : VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM; |
| } |
| virtual VkPipelineDepthStencilStateCreateFlags getDSStateFlags() const |
| { |
| return 0; |
| } |
| virtual bool hasDepth() const |
| { |
| return false; |
| } |
| virtual bool hasStencil() const |
| { |
| return false; |
| } |
| |
| protected: |
| virtual void addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const = 0; |
| void addSimpleVertexShader(SourceCollections& programCollection, const std::string &dest) const; |
| virtual void checkAdditionalRasterizationFlags(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &rasterizationAccess) const |
| { |
| // unused parameter |
| DE_UNREF(rasterizationAccess); |
| } |
| }; |
| |
| class AttachmentAccessOrderColorTestCase : public AttachmentAccessOrderTestCase |
| { |
| public: |
| AttachmentAccessOrderColorTestCase( tcu::TestContext& context, const std::string& name, const std::string& description, |
| bool explicitSync, bool overlapDraws, bool overlapPrimitives, bool overlapInstances, |
| VkSampleCountFlagBits sampleCount, deUint32 inputAttachmentNum, bool integerFormat) |
| :AttachmentAccessOrderTestCase( context, name, description, explicitSync, overlapDraws, overlapPrimitives, overlapInstances, sampleCount, |
| inputAttachmentNum, integerFormat) |
| {} |
| |
| virtual deUint32 getInputAttachmentNum() const |
| { |
| return m_inputAttachmentNum; |
| } |
| |
| virtual deUint32 getColorAttachmentNum() const |
| { |
| return m_inputAttachmentNum; |
| } |
| |
| virtual bool hasDepthStencil() const |
| { |
| return false; |
| } |
| |
| virtual VkImageAspectFlagBits getDSAspect() const |
| { |
| /* not relevant, this return value will not be used */ |
| return VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM; |
| } |
| protected: |
| virtual void addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const; |
| }; |
| |
| class AttachmentAccessOrderDepthTestCase : public AttachmentAccessOrderTestCase |
| { |
| public: |
| AttachmentAccessOrderDepthTestCase( tcu::TestContext& context, const std::string& name, const std::string& description, |
| bool explicitSync, bool overlapDraws, bool overlapPrimitives, bool overlapInstances, |
| VkSampleCountFlagBits sampleCount) |
| :AttachmentAccessOrderTestCase( context, name, description, explicitSync, overlapDraws, overlapPrimitives, overlapInstances, sampleCount, |
| 1, false) |
| {} |
| virtual deUint32 getInputAttachmentNum() const |
| { |
| return m_inputAttachmentNum + 1; |
| } |
| |
| virtual deUint32 getColorAttachmentNum() const |
| { |
| return m_inputAttachmentNum; |
| } |
| |
| virtual bool hasDepth() const |
| { |
| return true; |
| } |
| virtual bool hasDepthStencil() const |
| { |
| return true; |
| } |
| |
| virtual VkImageAspectFlagBits getDSAspect() const |
| { |
| return VK_IMAGE_ASPECT_DEPTH_BIT; |
| } |
| virtual VkPipelineDepthStencilStateCreateFlags getDSStateFlags() const |
| { |
| return m_explicitSync ? 0 : VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM; |
| } |
| protected: |
| virtual void addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const; |
| virtual void checkAdditionalRasterizationFlags(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &rasterizationAccess) const |
| { |
| if (!m_explicitSync && !rasterizationAccess.rasterizationOrderDepthAttachmentAccess) |
| { |
| TCU_THROW(NotSupportedError , "Implicit attachment access rasterization order not guaranteed for depth attachments"); |
| } |
| } |
| }; |
| |
| class AttachmentAccessOrderStencilTestCase : public AttachmentAccessOrderTestCase |
| { |
| public: |
| AttachmentAccessOrderStencilTestCase( tcu::TestContext& context, const std::string& name, const std::string& description, |
| bool explicitSync, bool overlapDraws, bool overlapPrimitives, bool overlapInstances, |
| VkSampleCountFlagBits sampleCount) |
| :AttachmentAccessOrderTestCase( context, name, description, explicitSync, overlapDraws, overlapPrimitives, overlapInstances, sampleCount, |
| 1, true) |
| {} |
| virtual deUint32 getInputAttachmentNum() const |
| { |
| return m_inputAttachmentNum + 1; |
| } |
| |
| virtual deUint32 getColorAttachmentNum() const |
| { |
| return m_inputAttachmentNum; |
| } |
| |
| virtual bool hasStencil() const |
| { |
| return true; |
| } |
| virtual bool hasDepthStencil() const |
| { |
| return true; |
| } |
| |
| virtual VkImageAspectFlagBits getDSAspect() const |
| { |
| return VK_IMAGE_ASPECT_STENCIL_BIT; |
| } |
| virtual VkPipelineDepthStencilStateCreateFlags getDSStateFlags() const |
| { |
| return m_explicitSync ? 0 : VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM; |
| } |
| protected: |
| virtual void addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const; |
| virtual void checkAdditionalRasterizationFlags(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &rasterizationAccess) const |
| { |
| if (!m_explicitSync && !rasterizationAccess.rasterizationOrderStencilAttachmentAccess) |
| { |
| TCU_THROW(NotSupportedError , "Implicit attachment access rasterization order not guaranteed for stencil attachments"); |
| } |
| } |
| }; |
| |
| |
| class AttachmentAccessOrderTestInstance : public TestInstance |
| { |
| public: |
| AttachmentAccessOrderTestInstance (Context& context, const AttachmentAccessOrderTestCase *testCase); |
| virtual ~AttachmentAccessOrderTestInstance (void); |
| virtual tcu::TestStatus iterate (void); |
| protected: |
| class RenderSubpass |
| { |
| public: |
| const AttachmentAccessOrderTestCase *m_testCase; |
| deUint32 m_subpass; |
| VkSampleCountFlagBits m_sampleCount; |
| Move<VkPipeline> m_pipeline; |
| Move<VkPipelineLayout> m_pipelineLayout; |
| deUint32 m_colorAttNum; |
| std::vector<Move<VkImage> > m_inputAtt; |
| std::vector<MovePtr<Allocation> > m_inputAttMemory; |
| std::vector<Move<VkImageView> > m_inputAttView; |
| std::vector<VkAttachmentReference> m_attachmentReferences; |
| |
| void createAttachments( int subpass, deUint32 inputAttachmentNum, deUint32 colorAttachmentNum, VkSampleCountFlagBits sampleCount, |
| Context &context, vector<VkImageView> &views, VkDescriptorSetLayout *pDsetLayout, const AttachmentAccessOrderTestCase *tc); |
| void createPipeline(VkRenderPass renderPass, Context &context); |
| |
| deUint32 getColorAttachmentNum() |
| { |
| return m_colorAttNum; |
| } |
| deUint32 getInputAttachmentNum() |
| { |
| return static_cast<deUint32>(m_inputAtt.size()); |
| } |
| VkAttachmentReference* getDepthStencilAttachment() |
| { |
| return (getColorAttachmentNum() == getInputAttachmentNum()) ? DE_NULL : &m_attachmentReferences[m_colorAttNum]; |
| } |
| }; |
| void addPipelineBarrier( VkCommandBuffer cmdBuffer, |
| VkImage image, |
| VkImageLayout oldLayout, |
| VkImageLayout newLayout, |
| VkAccessFlags srcAccessMask, |
| VkAccessFlags dstAccessMask, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT); |
| |
| void addClearColor(VkCommandBuffer cmdBuffer, VkImage image); |
| void addClearDepthStencil(VkCommandBuffer cmdBuffer, VkImage image); |
| |
| void writeDescriptorSets(); |
| Move<VkRenderPass> createRenderPass(VkFormat attFormat); |
| void createVertexBuffer(); |
| void createResultBuffer(); |
| void addDependency( vector<VkSubpassDependency> &dependencies, deUint32 source, deUint32 dst, |
| VkPipelineStageFlags pipelineFlags, VkAccessFlags accessFlags); |
| |
| tcu::TestStatus validateResults(deUint32 numDraws, deUint32 numPrimitives, deUint32 numInstances); |
| |
| const AttachmentAccessOrderTestCase *m_testCase; |
| |
| |
| const DeviceInterface& m_vk; |
| vector<RenderSubpass> m_subpasses; |
| Move<VkRenderPass> m_renderPass; |
| Move<VkFramebuffer> m_framebuffer; |
| Move<VkBuffer> m_vertexBuffer; |
| MovePtr<Allocation> m_vertexBufferMemory; |
| Move<VkCommandPool> m_cmdPool; |
| Move<VkCommandBuffer> m_cmdBuffer; |
| Move<VkSampler> m_sampler; |
| Move<VkDescriptorSetLayout> m_descSetLayout; |
| Move<VkDescriptorPool> m_descPool; |
| Move<VkDescriptorSet> m_descSet; |
| |
| Move<VkBuffer> m_resultBuffer; |
| MovePtr<Allocation> m_resultBufferMemory; |
| |
| enum |
| { |
| WIDTH = 8, |
| HEIGHT = 8, |
| }; |
| }; |
| |
| AttachmentAccessOrderTestCase::AttachmentAccessOrderTestCase ( tcu::TestContext& context, const std::string& name, const std::string& description, |
| bool explicitSync, bool overlapDraws, bool overlapPrimitives, bool overlapInstances, |
| VkSampleCountFlagBits sampleCount, deUint32 inputAttachmentNum, bool integerFormat) |
| : TestCase(context, name, description) |
| , m_inputAttachmentNum(inputAttachmentNum) |
| , m_explicitSync(explicitSync) |
| , m_overlapDraws(overlapDraws) |
| , m_overlapPrimitives(overlapPrimitives) |
| , m_overlapInstances(overlapInstances) |
| , m_sampleCount(sampleCount) |
| , m_sampleNum(getSampleNum(sampleCount)) |
| , m_integerFormat(integerFormat) |
| { |
| } |
| |
| AttachmentAccessOrderTestCase::~AttachmentAccessOrderTestCase (void) |
| { |
| } |
| void AttachmentAccessOrderTestCase::addSimpleVertexShader(SourceCollections& programCollection, const std::string &dest) const |
| { |
| std::stringstream vertShader; |
| vertShader << "#version 310 es\n" |
| << "layout(location = 0) in highp vec2 v_position;\n" |
| << "void main ()\n" |
| << "{\n" |
| << " gl_Position = vec4(v_position, float(gl_InstanceIndex)/256.0, 1);\n" |
| << "}\n"; |
| programCollection.glslSources.add(dest) << glu::VertexSource(vertShader.str()); |
| } |
| |
| void AttachmentAccessOrderColorTestCase::addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const |
| { |
| addSimpleVertexShader(programCollection, "vert1"); |
| addSimpleVertexShader(programCollection, "vert2"); |
| |
| std::stringstream fragShader; |
| fragShader << "#version 450\n" |
| << "precision highp ${SCALAR_NAME};\n" |
| << "precision highp ${SUBPASS_INPUT};\n"; |
| for (deUint32 i=0; i < m_inputAttachmentNum; i++) |
| { |
| fragShader << "layout( set = 0, binding = " << i << ", input_attachment_index = " << i << " ) uniform ${SUBPASS_INPUT} in" << i << ";\n" |
| << "layout( location = " << i << " ) out ${VEC_NAME}2 out" << i << ";\n"; |
| } |
| |
| |
| fragShader << "layout( push_constant ) uniform ConstBlock\n" |
| << "{\n" |
| << " uint drawCur;\n" |
| << "};\n" |
| << "void main()\n" |
| << "{\n" |
| << " uint instanceCur = uint(round(gl_FragCoord.z * 256.0));\n" |
| << " uint primitiveCur = uint(gl_PrimitiveID) / 2u;\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM}u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM}u;\n" |
| << " uint drawNum = ${DRAW_NUM}u;\n" |
| << " uint curIndex = drawCur * instanceNum * primitiveNum + instanceCur * primitiveNum + primitiveCur;\n" |
| << " uint total = drawNum * instanceNum * primitiveNum;\n" |
| << " uint zero = curIndex / total;\n" |
| << " uint index;\n" |
| << " uint pre_fetch_loop = uint(gl_FragCoord.x) * uint(gl_FragCoord.y) * (drawNum * primitiveNum - drawCur * primitiveNum - primitiveCur);\n" |
| << " uint post_fetch_loop = uint(gl_FragCoord.x) + uint(gl_FragCoord.y) + (drawNum * instanceNum - drawCur * instanceNum - instanceCur);\n" |
| << " for(index = 0u; index < pre_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n" |
| << " ${VEC_NAME}2 previous[${ATT_NUM}];\n"; |
| |
| for (deUint32 i=0; i < m_inputAttachmentNum; i++) |
| { |
| if (m_sampleCount == VK_SAMPLE_COUNT_1_BIT) |
| { |
| fragShader << " previous[" << i << "] = subpassLoad( in" << i << ").xy;\n"; |
| } |
| else |
| { |
| fragShader << " previous[" << i << "] = subpassLoad( in" << i << ", gl_SampleID).xy;\n"; |
| } |
| } |
| fragShader << " for(index = 0u; index < post_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n"; |
| for (deUint32 i=0; i < m_inputAttachmentNum; i++) |
| { |
| fragShader << " if (previous[" << i << "].y == 0 && curIndex == 0)\n" |
| << " {\n" |
| << " out" << i << ".y = previous[" << i << "].y + (1u + zero + gl_SampleID + " << i << "u);\n" |
| << " out" << i << ".x = previous[" << i << "].x;\n" |
| << " }\n" |
| << " else if (previous[" << i << "].y == curIndex + gl_SampleID + " << i << ")\n" |
| << " {\n" |
| << " out" << i << ".y = previous[" << i << "].y + 1 + zero;\n" |
| << " out" << i << ".x = previous[" << i << "].x;\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " out" << i << ".y = 0u;\n" |
| << " out" << i << ".x = 1u;\n" |
| << " }\n"; |
| } |
| fragShader << "}\n"; |
| |
| tcu::StringTemplate fragShaderTpl(fragShader.str()); |
| |
| programCollection.glslSources.add("frag") << glu::FragmentSource(fragShaderTpl.specialize(params)); |
| } |
| void AttachmentAccessOrderDepthTestCase::addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const |
| { |
| std::stringstream vertShader; |
| vertShader << "#version 460\n" |
| << "layout(location = 0) in highp vec2 v_position;\n" |
| << "layout(location = 1) flat out uint instance_index;" |
| << "layout( push_constant ) uniform ConstBlock\n" |
| << "{\n" |
| << " uint drawCur;\n" |
| << "};\n" |
| << "void main ()\n" |
| << "{\n" |
| << " uint primitiveCur = uint(gl_VertexIndex) / 6u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM};\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM};\n" |
| << " uint drawNum = ${DRAW_NUM};\n" |
| << " uint curIndex = drawCur * instanceNum * primitiveNum + gl_InstanceIndex * primitiveNum + primitiveCur;\n" |
| << " uint indexNum = drawNum * instanceNum * primitiveNum;\n" |
| << " instance_index = gl_InstanceIndex;\n" |
| << " gl_Position = vec4(v_position, 0.125 * float(curIndex) / float(indexNum), 1);\n" |
| << "}\n"; |
| |
| tcu::StringTemplate vertShaderTpl(vertShader.str()); |
| programCollection.glslSources.add("vert1") << glu::VertexSource(vertShaderTpl.specialize(params)); |
| addSimpleVertexShader(programCollection, "vert2"); |
| |
| std::stringstream fragShader; |
| fragShader << "#version 450\n" |
| << "precision highp ${SCALAR_NAME};\n" |
| << "precision highp ${SUBPASS_INPUT};\n" |
| << "layout( set = 0, binding = 0, input_attachment_index = 0 ) uniform ${SUBPASS_INPUT} in_color;\n" |
| << "layout( set = 0, binding = 1, input_attachment_index = 1 ) uniform ${SUBPASS_INPUT} in_ds;\n" |
| << "layout( location = 0 ) out ${VEC_NAME}2 out0;\n" |
| << "layout( location = 1 ) flat in uint instance_index;\n" |
| << "layout( push_constant ) uniform ConstBlock\n" |
| << "{\n" |
| << " uint drawCur;\n" |
| << "};\n" |
| << "void main()\n" |
| << "{\n" |
| << " uint instanceCur = instance_index;\n" |
| << " uint primitiveCur = uint(gl_PrimitiveID) / 2u;\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM}u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM}u;\n" |
| << " uint drawNum = ${DRAW_NUM}u;\n" |
| << " uint curIndex = drawCur * instanceNum * primitiveNum + instanceCur * primitiveNum + primitiveCur;\n" |
| << " uint total = drawNum * instanceNum * primitiveNum;\n" |
| << " uint zero = curIndex / total;\n" |
| << " uint index;\n" |
| << " uint pre_fetch_loop = uint(gl_FragCoord.x) * uint(gl_FragCoord.y) * (drawNum * primitiveNum - drawCur * primitiveNum - primitiveCur);\n" |
| << " uint post_fetch_loop = uint(gl_FragCoord.x) + uint(gl_FragCoord.y) + (drawNum * instanceNum - drawCur * instanceNum - instanceCur);\n" |
| << " for(index = 0u; index < pre_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n"; |
| if (m_sampleCount == VK_SAMPLE_COUNT_1_BIT) |
| { |
| fragShader << " vec2 ds = subpassLoad( in_ds ).xy;\n" |
| << " ${VEC_NAME}2 color = subpassLoad( in_color ).xy;\n"; |
| } |
| else |
| { |
| fragShader << " vec2 ds = subpassLoad( in_ds, gl_SampleID ).xy;\n" |
| << " ${VEC_NAME}2 color = subpassLoad( in_color, gl_SampleID ).xy;\n"; |
| } |
| fragShader << " for(index = 0u; index < post_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n" |
| << " if (curIndex == 0 && ds.x == 0)\n" |
| << " {\n" |
| << " out0.x = color.x;\n" |
| << " out0.y = curIndex + 1 + gl_SampleID + zero;\n"; |
| if (m_sampleCount != VK_SAMPLE_COUNT_1_BIT) |
| { |
| fragShader << " gl_FragDepth = 0.125 * (float(curIndex) / float(total)) + gl_SampleID / 128.0;\n"; |
| } |
| fragShader << " }\n" |
| << " else if (ds.x == 0.125 * float(curIndex - 1) / float(total) + gl_SampleID / 128.0)\n" |
| << " {\n" |
| << " out0.x = color.x;\n" |
| << " out0.y = curIndex + 1 + gl_SampleID + zero;\n"; |
| if (m_sampleCount != VK_SAMPLE_COUNT_1_BIT) |
| { |
| fragShader << " gl_FragDepth = 0.125 * (float(curIndex) / float(total)) + gl_SampleID / 128.0;\n"; |
| } |
| fragShader << " }\n" |
| << " else\n" |
| << " {\n" |
| << " out0.y = 0;\n" |
| << " out0.x = 1u;\n" |
| << " }\n" |
| << "}\n"; |
| |
| tcu::StringTemplate fragShaderTpl(fragShader.str()); |
| |
| programCollection.glslSources.add("frag") << glu::FragmentSource(fragShaderTpl.specialize(params)); |
| } |
| void AttachmentAccessOrderStencilTestCase::addShadersInternal(SourceCollections& programCollection, const std::map<std::string, std::string> ¶ms) const |
| { |
| std::stringstream vertShader; |
| vertShader << "#version 460\n" |
| << "layout(location = 0) in highp vec2 v_position;\n" |
| << "layout(location = 1) flat out uint instance_index;" |
| << "layout( push_constant ) uniform ConstBlock\n" |
| << "{\n" |
| << " uint drawCur;\n" |
| << "};\n" |
| << "void main ()\n" |
| << "{\n" |
| << " uint primitiveCur = uint(gl_VertexIndex) / 6u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM};\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM};\n" |
| << " uint drawNum = ${DRAW_NUM};\n" |
| << " uint curIndex = drawCur * instanceNum * primitiveNum + gl_InstanceIndex * primitiveNum + primitiveCur;\n" |
| << " uint indexNum = drawNum * instanceNum * primitiveNum;\n" |
| << " instance_index = gl_InstanceIndex;\n" |
| << " gl_Position = vec4(v_position, 0.125 * float(curIndex) / float(indexNum), 1);\n" |
| << "}\n"; |
| |
| tcu::StringTemplate vertShaderTpl(vertShader.str()); |
| programCollection.glslSources.add("vert1") << glu::VertexSource(vertShaderTpl.specialize(params)); |
| addSimpleVertexShader(programCollection, "vert2"); |
| |
| std::stringstream fragShader; |
| fragShader << "#version 450\n" |
| << "precision highp ${SCALAR_NAME};\n" |
| << "precision highp ${SUBPASS_INPUT};\n" |
| << "layout( set = 0, binding = 0, input_attachment_index = 0 ) uniform ${SUBPASS_INPUT} in_color;\n" |
| << "layout( set = 0, binding = 1, input_attachment_index = 1 ) uniform ${SUBPASS_INPUT} in_ds;\n" |
| << "layout( location = 0 ) out ${VEC_NAME}2 out0;\n" |
| << "layout( location = 1 ) flat in uint instance_index;\n" |
| << "layout( push_constant ) uniform ConstBlock\n" |
| << "{\n" |
| << " uint drawCur;\n" |
| << "};\n" |
| << "void main()\n" |
| << "{\n" |
| << " uint instanceCur = instance_index;\n" |
| << " uint primitiveCur = uint(gl_PrimitiveID) / 2u;\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM}u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM}u;\n" |
| << " uint drawNum = ${DRAW_NUM}u;\n" |
| << " uint curIndex = drawCur * instanceNum * primitiveNum + instanceCur * primitiveNum + primitiveCur;\n" |
| << " uint total = drawNum * instanceNum * primitiveNum;\n" |
| << " uint zero = curIndex / total;\n" |
| << " uint index;\n" |
| << " uint pre_fetch_loop = uint(gl_FragCoord.x) * uint(gl_FragCoord.y) * (drawNum * primitiveNum - drawCur * primitiveNum - primitiveCur);\n" |
| << " uint post_fetch_loop = uint(gl_FragCoord.x) + uint(gl_FragCoord.y) + (drawNum * instanceNum - drawCur * instanceNum - instanceCur);\n" |
| << " for(index = 0u; index < pre_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n"; |
| if (m_sampleCount == VK_SAMPLE_COUNT_1_BIT) |
| { |
| fragShader << " ${VEC_NAME}2 ds = subpassLoad( in_ds ).xy;\n" |
| << " ${VEC_NAME}2 color = subpassLoad( in_color ).xy;\n"; |
| } |
| else |
| { |
| fragShader << " ${VEC_NAME}2 ds = subpassLoad( in_ds, gl_SampleID).xy;\n" |
| << " ${VEC_NAME}2 color = subpassLoad( in_color, gl_SampleID).xy;\n"; |
| } |
| fragShader << " for(index = 0u; index < post_fetch_loop; index++)\n" |
| << " {\n" |
| << " zero = uint(sin(float(zero)));\n" |
| << " }\n" |
| << " if (ds.x == curIndex)\n" |
| << " {\n" |
| << " out0.x = color.x;\n" |
| << " out0.y = curIndex + 1 + gl_SampleID + zero;\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " out0.y = 0;\n" |
| << " out0.x = 1u;\n" |
| << " }\n" |
| << "}\n"; |
| |
| tcu::StringTemplate fragShaderTpl(fragShader.str()); |
| |
| programCollection.glslSources.add("frag") << glu::FragmentSource(fragShaderTpl.specialize(params)); |
| } |
| |
| void AttachmentAccessOrderTestCase::initPrograms (SourceCollections& programCollection) const |
| { |
| std::map<std::string, std::string> params; |
| |
| params["PRIMITIVE_NUM"] = std::to_string(m_overlapPrimitives?ELEM_NUM:1); |
| params["INSTANCE_NUM"] = std::to_string(m_overlapInstances?ELEM_NUM:1); |
| params["DRAW_NUM"] = std::to_string(m_overlapDraws?ELEM_NUM:1); |
| params["ATT_NUM"] = std::to_string(m_inputAttachmentNum); |
| params["SAMPLE_NUM"] = std::to_string(m_sampleNum); |
| |
| if (m_integerFormat) |
| { |
| params["SUBPASS_INPUT"] = "usubpassInput"; |
| params["SCALAR_NAME"] = "int"; |
| params["VEC_NAME"] = "uvec"; |
| } |
| else |
| { |
| params["SUBPASS_INPUT"] = "subpassInput"; |
| params["SCALAR_NAME"] = "float"; |
| params["VEC_NAME"] = "vec"; |
| } |
| if (m_sampleCount != VK_SAMPLE_COUNT_1_BIT) |
| { |
| params["SUBPASS_INPUT"] = params["SUBPASS_INPUT"] + "MS"; |
| } |
| |
| /* add the vertex (for both renderpasses) and fragment shaders for first renderpass */ |
| addShadersInternal(programCollection, params); |
| |
| std::stringstream fragShaderResolve; |
| fragShaderResolve << "#version 450\n" |
| << "precision highp ${SCALAR_NAME};\n" |
| << "precision highp ${SUBPASS_INPUT};\n"; |
| for (deUint32 i=0; i < m_inputAttachmentNum; i++) |
| { |
| fragShaderResolve << "layout( set = 0, binding = " << i << ", input_attachment_index = " << i << " ) uniform ${SUBPASS_INPUT} in" << i << ";\n"; |
| } |
| fragShaderResolve << "layout( location = 0 ) out ${VEC_NAME}2 out0;\n"; |
| |
| fragShaderResolve << "void main()\n" |
| << "{\n" |
| << " uint primitiveNum = ${PRIMITIVE_NUM}u;\n" |
| << " uint instanceNum = ${INSTANCE_NUM}u;\n" |
| << " uint drawNum = ${DRAW_NUM}u;\n" |
| << " uint sampleNum = ${SAMPLE_NUM}u;\n" |
| << " uint totalNum = primitiveNum * instanceNum * drawNum;\n" |
| << " out0.y = totalNum;\n" |
| << " out0.x = 0u;\n" |
| << " ${VEC_NAME}2 val;\n" |
| << " int i;\n"; |
| |
| for (deUint32 i=0; i < m_inputAttachmentNum; i++) |
| { |
| if (m_sampleNum == 1) |
| { |
| fragShaderResolve << " val = subpassLoad(in" << i << ").xy;\n" |
| << " if (val.x != 0u || val.y != totalNum + " << i << "){\n" |
| << " out0.y = val.y;\n" |
| << " out0.x = val.x;\n" |
| << " }\n"; |
| } |
| else |
| { |
| fragShaderResolve << " for (i = 0; i < sampleNum; i++) {\n" |
| << " val = subpassLoad(in" << i << ", i).xy;\n" |
| << " if (val.x != 0u || val.y != totalNum + i + " << i << "){\n" |
| << " out0.y = val.y;\n" |
| << " out0.x = val.x;\n" |
| << " }\n" |
| << " }\n"; |
| } |
| } |
| |
| fragShaderResolve << "}\n"; |
| |
| tcu::StringTemplate fragShaderResolveTpl(fragShaderResolve.str()); |
| |
| programCollection.glslSources.add("frag_resolve") << glu::FragmentSource(fragShaderResolveTpl.specialize(params)); |
| } |
| |
| |
| TestInstance* AttachmentAccessOrderTestCase::createInstance (Context& context) const |
| { |
| return new AttachmentAccessOrderTestInstance(context, this); |
| } |
| |
| void AttachmentAccessOrderTestCase::checkSupport (Context& context) const |
| { |
| context.requireDeviceFunctionality("VK_ARM_rasterization_order_attachment_access"); |
| |
| VkPhysicalDeviceVulkan12Properties vulkan12Properties = {}; |
| vulkan12Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; |
| |
| VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM rasterizationAccess = {}; |
| rasterizationAccess.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM; |
| rasterizationAccess.pNext = &vulkan12Properties; |
| |
| VkPhysicalDeviceProperties2 properties = {}; |
| properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; |
| properties.pNext = &rasterizationAccess; |
| |
| VkPhysicalDeviceFeatures features = {}; |
| |
| context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties); |
| context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &features); |
| |
| if ( m_integerFormat ) |
| { |
| if ((vulkan12Properties.framebufferIntegerColorSampleCounts & m_sampleCount) == 0 || |
| (properties.properties.limits.sampledImageIntegerSampleCounts & m_sampleCount) == 0) |
| { |
| TCU_THROW(NotSupportedError, "Sample count not supported"); |
| } |
| } |
| else |
| { |
| if ((properties.properties.limits.framebufferColorSampleCounts & m_sampleCount) == 0 || |
| (properties.properties.limits.sampledImageColorSampleCounts & m_sampleCount) == 0) |
| { |
| TCU_THROW(NotSupportedError , "Sample count not supported"); |
| } |
| } |
| |
| /* sampleRateShading must be enabled to call fragment shader for all the samples in multisampling */ |
| if ( (m_sampleCount != VK_SAMPLE_COUNT_1_BIT && !features.sampleRateShading) ) |
| { |
| TCU_THROW(NotSupportedError , "sampleRateShading feature not supported"); |
| } |
| |
| /* Needed for gl_PrimitiveID */ |
| if ( !features.geometryShader ) |
| { |
| TCU_THROW(NotSupportedError , "geometryShader feature not supported"); |
| } |
| |
| if (properties.properties.limits.maxFragmentOutputAttachments < m_inputAttachmentNum || |
| properties.properties.limits.maxPerStageDescriptorInputAttachments < m_inputAttachmentNum) |
| { |
| TCU_THROW(NotSupportedError , "Feedback attachment number not supported"); |
| } |
| |
| if (!m_explicitSync && !rasterizationAccess.rasterizationOrderColorAttachmentAccess) |
| { |
| TCU_THROW(NotSupportedError , "Implicit attachment access rasterization order not guaranteed for color attachments"); |
| } |
| |
| checkAdditionalRasterizationFlags(rasterizationAccess); |
| } |
| |
| deUint32 AttachmentAccessOrderTestCase::getSampleNum(VkSampleCountFlagBits sampleCount) |
| { |
| deUint32 ret = 0; |
| switch(sampleCount) |
| { |
| case VK_SAMPLE_COUNT_1_BIT: ret = 1; break; |
| case VK_SAMPLE_COUNT_2_BIT: ret = 2; break; |
| case VK_SAMPLE_COUNT_4_BIT: ret = 4; break; |
| case VK_SAMPLE_COUNT_8_BIT: ret = 8; break; |
| case VK_SAMPLE_COUNT_16_BIT: ret = 16; break; |
| case VK_SAMPLE_COUNT_32_BIT: ret = 32; break; |
| case VK_SAMPLE_COUNT_64_BIT: ret = 64; break; |
| default: DE_ASSERT(false); |
| }; |
| return ret; |
| } |
| |
| void AttachmentAccessOrderTestInstance::RenderSubpass::createAttachments( int subpass, deUint32 inputAttachmentNum, deUint32 colorAttachmentNum, |
| VkSampleCountFlagBits sampleCount, |
| Context &context, vector<VkImageView> &views, VkDescriptorSetLayout *pDsetLayout, |
| const AttachmentAccessOrderTestCase *tc) |
| { |
| m_testCase = tc; |
| m_subpass = subpass; |
| m_sampleCount = sampleCount; |
| m_colorAttNum = colorAttachmentNum; |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice device = context.getDevice(); |
| const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); |
| Allocator& allocator = context.getDefaultAllocator(); |
| |
| // Pipeline Layout |
| { |
| VkPushConstantRange pushConstantsInfo = |
| { |
| VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags; |
| 0, // uint32_t offset; |
| 4, // uint32_t size; |
| }; |
| if (m_testCase->hasDepthStencil()) |
| { |
| pushConstantsInfo.stageFlags |= VK_SHADER_STAGE_VERTEX_BIT; |
| } |
| const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkPipelineLayoutCreateFlags flags; |
| 1u, // deUint32 descriptorSetCount; |
| pDsetLayout, // const VkDescriptorSetLayout* pSetLayouts; |
| m_subpass == 0 ? 1u : 0u, // deUint32 pushConstantRangeCount; |
| m_subpass == 0 ? &pushConstantsInfo : nullptr // const VkPushConstantRange* pPushConstantRanges; |
| }; |
| m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo); |
| } |
| VkFormat attFormat = m_testCase->getColorFormat(); |
| |
| /* Same create info for all the color attachments */ |
| VkImageCreateInfo colorImageCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkImageCreateFlags flags; |
| VK_IMAGE_TYPE_2D, // VkImageType imageType; |
| attFormat, // VkFormat format; |
| { WIDTH, HEIGHT, 1u }, // VkExtent3D extent; |
| 1u, // deUint32 mipLevels; |
| 1u, // deUint32 arrayLayers; |
| sampleCount, // VkSampleCountFlagBits samples; |
| VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; |
| VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | |
| 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; |
| }; |
| |
| for (deUint32 i = 0; i < inputAttachmentNum; i++) |
| { |
| VkImageAspectFlagBits aspect = VK_IMAGE_ASPECT_COLOR_BIT; |
| |
| /* Image for the DS attachment */ |
| if (i >= colorAttachmentNum) |
| { |
| attFormat = m_testCase->getDSFormat(); |
| colorImageCreateInfo.format = attFormat; |
| colorImageCreateInfo.usage &= ~VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| colorImageCreateInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; |
| aspect = m_testCase->getDSAspect(); |
| } |
| |
| m_inputAtt.push_back(createImage(vk, device, &colorImageCreateInfo, DE_NULL)); |
| VkImageViewCreateInfo colorTargetViewInfo = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkImageViewCreateFlags flags; |
| *m_inputAtt.back(), // VkImage image; |
| VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; |
| attFormat, // VkFormat format; |
| makeComponentMappingRGBA(), // VkComponentMapping components; |
| { |
| aspect, // VkImageAspectFlags aspectMask; |
| 0u, // deUint32 baseMipLevel; |
| 1u, // deUint32 mipLevels; |
| 0u, // deUint32 baseArrayLayer; |
| 1u, // deUint32 arraySize; |
| }, // VkImageSubresourceRange subresourceRange; |
| }; |
| m_inputAttMemory.push_back(allocator.allocate(getImageMemoryRequirements(vk, device, *m_inputAtt.back()), MemoryRequirement::Any)); |
| VK_CHECK(vk.bindImageMemory(device, *m_inputAtt.back(), m_inputAttMemory.back()->getMemory(), m_inputAttMemory.back()->getOffset())); |
| m_inputAttView.push_back(createImageView(vk, device, &colorTargetViewInfo)); |
| |
| m_attachmentReferences.push_back({(deUint32)views.size(), VK_IMAGE_LAYOUT_GENERAL}); |
| views.push_back(*m_inputAttView.back()); |
| } |
| } |
| |
| void AttachmentAccessOrderTestInstance::RenderSubpass::createPipeline(VkRenderPass renderPass, Context &context) |
| { |
| |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice device = context.getDevice(); |
| const Unique<VkShaderModule> vs(createShaderModule(vk, device, context.getBinaryCollection().get(m_subpass == 0 ? "vert1" : "vert2"), 0)); |
| const Unique<VkShaderModule> fs(createShaderModule(vk, device, context.getBinaryCollection().get(m_subpass == 0 ? "frag" : "frag_resolve"), 0)); |
| |
| const VkVertexInputBindingDescription vertexInputBindingDescription = |
| { |
| 0, // deUint32 binding; |
| sizeof(tcu::Vec2), // deUint32 strideInBytes; |
| VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputStepRate stepRate; |
| }; |
| |
| const VkVertexInputAttributeDescription vertexInputAttributeDescription = |
| { |
| 0u, // deUint32 location; |
| 0u, // deUint32 binding; |
| VK_FORMAT_R32G32_SFLOAT, // VkFormat format; |
| 0u, // deUint32 offsetInBytes; |
| }; |
| |
| const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0, // VkPipelineVertexInputStateCreateFlags flags; |
| 1u, // deUint32 bindingCount; |
| &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; |
| 1u, // deUint32 attributeCount; |
| &vertexInputAttributeDescription, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; |
| }; |
| |
| const std::vector<VkViewport> viewports(1, {0, 0, WIDTH, HEIGHT, 0, 1}); |
| const std::vector<VkRect2D> scissors(1, { {0, 0}, {WIDTH, HEIGHT} }); |
| const VkPipelineRasterizationStateCreateInfo rasterizationStateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkPipelineRasterizationStateCreateFlags flags; |
| VK_FALSE, // VkBool32 depthClampEnable; |
| VK_FALSE, // VkBool32 rasterizerDiscardEnable; |
| VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; |
| VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; |
| VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; |
| VK_FALSE, // VkBool32 depthBiasEnable; |
| 0.0f, // float depthBiasConstantFactor; |
| 0.0f, // float depthBiasClamp; |
| 0.0f, // float depthBiasSlopeFactor; |
| 1.0f, // float lineWidth; |
| }; |
| const VkPipelineMultisampleStateCreateInfo multisampleStateParams = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkPipelineMultisampleStateCreateFlags flags; |
| m_sampleCount, // VkSampleCountFlagBits rasterizationSamples; |
| VK_TRUE, // VkBool32 sampleShadingEnable; |
| 1.0f, // float minSampleShading; |
| DE_NULL, // const VkSampleMask* pSampleMask; |
| VK_FALSE, // VkBool32 alphaToCoverageEnable; |
| VK_FALSE // VkBool32 alphaToOneEnable; |
| }; |
| std::vector<VkPipelineColorBlendAttachmentState> colorBlendAttachmentState(m_colorAttNum, |
| { |
| false, // VkBool32 blendEnable; |
| VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor; |
| VK_BLEND_FACTOR_ONE, // VkBlend destBlendColor; |
| VK_BLEND_OP_ADD, // VkBlendOp blendOpColor; |
| VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha; |
| VK_BLEND_FACTOR_ONE, // VkBlend destBlendAlpha; |
| VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha; |
| (VK_COLOR_COMPONENT_R_BIT | |
| VK_COLOR_COMPONENT_G_BIT) // VkChannelFlags channelWriteMask; |
| }); |
| |
| const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| /* always needed */ |
| m_testCase->getBlendStateFlags(), // VkPipelineColorBlendStateCreateFlags flags; |
| false, // VkBool32 logicOpEnable; |
| VK_LOGIC_OP_COPY, // VkLogicOp logicOp; |
| (deUint32)colorBlendAttachmentState.size(), // deUint32 attachmentCount; |
| colorBlendAttachmentState.data(), // const VkPipelineColorBlendAttachmentState* pAttachments; |
| { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4]; |
| }; |
| |
| VkStencilOpState stencilOpState = |
| { |
| VK_STENCIL_OP_ZERO, // VkStencilOp failOp; |
| VK_STENCIL_OP_INCREMENT_AND_WRAP, // VkStencilOp passOp; |
| VK_STENCIL_OP_INCREMENT_AND_WRAP, // VkStencilOp depthFailOp; |
| VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp; |
| 0xff, // uint32_t compareMask; |
| 0xff, // uint32_t writeMask; |
| 0, // uint32_t reference; |
| }; |
| VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, |
| // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| m_testCase->getDSStateFlags(), |
| // VkPipelineDepthStencilStateCreateFlags flags; |
| VK_TRUE, // VkBool32 depthTestEnable; |
| VK_TRUE, // VkBool32 depthWriteEnable; |
| VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp; |
| VK_FALSE, // VkBool32 depthBoundsTestEnable; |
| VK_TRUE, // VkBool32 stencilTestEnable; |
| stencilOpState, // VkStencilOpState front; |
| stencilOpState, // VkStencilOpState back; |
| 0.0f, // float minDepthBounds; |
| 1.0f, // float maxDepthBounds; |
| }; |
| |
| |
| m_pipeline = makeGraphicsPipeline( vk, // const DeviceInterface& vk |
| device, // const VkDevice device |
| *m_pipelineLayout, // const VkPipelineLayout pipelineLayout |
| *vs, // const VkShaderModule vertexShaderModule |
| DE_NULL, // const VkShaderModule tessellationControlShaderModule |
| DE_NULL, // const VkShaderModule tessellationEvalShaderModule |
| DE_NULL, // const VkShaderModule geometryShaderModule |
| *fs, // const VkShaderModule fragmentShaderModule |
| renderPass, // const VkRenderPass renderPass |
| viewports, // const std::vector<VkViewport>& viewports |
| scissors, // const std::vector<VkRect2D>& scissors |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,// const VkPrimitiveTopology topology |
| m_subpass, // const deUint32 subpass |
| 0u, // const deUint32 patchControlPoints |
| &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo |
| &rasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo |
| &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo |
| &depthStencilStateCreateInfo, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo, |
| &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo, |
| DE_NULL); // const VkPipelineDynamicStateCreateInfo* dynamicStateCreateInfo |
| } |
| |
| static Move<VkSampler> makeSampler (const DeviceInterface& vk, const VkDevice& device) |
| { |
| const VkSamplerCreateInfo createInfo = |
| { |
| 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_LINEAR, // 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; |
| VK_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 unnormalizedCoordinates; |
| }; |
| |
| return createSampler(vk, device, &createInfo); |
| } |
| |
| static Move<VkDescriptorSetLayout> makeDescriptorSetLayout(const DeviceInterface &vk, const VkDevice device, deUint32 attNum) |
| { |
| vector<VkDescriptorSetLayoutBinding> bindings(attNum, |
| { |
| 0, // binding |
| VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // descriptorType |
| 1u, // descriptorCount |
| VK_SHADER_STAGE_FRAGMENT_BIT, // stageFlags |
| DE_NULL, // pImmutableSamplers |
| }); |
| for (deUint32 i = 0; i < attNum; i++) |
| { |
| bindings[i].binding = i; |
| } |
| |
| const VkDescriptorSetLayoutCreateInfo layoutCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, |
| DE_NULL, // pNext |
| 0u, // flags |
| attNum, // bindingCount |
| bindings.data(), // pBindings |
| }; |
| |
| return vk::createDescriptorSetLayout(vk, device, &layoutCreateInfo); |
| } |
| void AttachmentAccessOrderTestInstance::writeDescriptorSets() |
| { |
| deUint32 attNum = m_testCase->getInputAttachmentNum(); |
| for (deUint32 i = 0 ; i < attNum ; i++ ) |
| { |
| VkDescriptorImageInfo img_info = {}; |
| img_info.sampler = *m_sampler; |
| img_info.imageView = *m_subpasses[0].m_inputAttView[i]; |
| img_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL; |
| |
| VkWriteDescriptorSet write = {}; |
| write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| write.dstSet = *m_descSet; |
| write.dstBinding = i; |
| write.dstArrayElement = 0; |
| write.descriptorCount = 1; |
| write.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; |
| write.pImageInfo = &img_info; |
| |
| m_vk.updateDescriptorSets(m_context.getDevice(), 1u, &write, 0u, DE_NULL); |
| } |
| } |
| |
| void AttachmentAccessOrderTestInstance::addDependency( vector<VkSubpassDependency> &dependencies, deUint32 source, deUint32 dst, |
| VkPipelineStageFlags pipelineFlags, VkAccessFlags accessFlags) |
| { |
| dependencies.push_back({ |
| source, //uint32_t srcSubpass; |
| dst, //uint32_t dstSubpass; |
| pipelineFlags, //VkPipelineStageFlags srcStageMask; |
| VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, //VkPipelineStageFlags dstStageMask; |
| accessFlags, //VkAccessFlags srcAccessMask; |
| VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, //VkAccessFlags dstAccessMask; |
| 0, //VkDependencyFlags dependencyFlags; |
| }); |
| } |
| Move<VkRenderPass> AttachmentAccessOrderTestInstance::createRenderPass(VkFormat attFormat) |
| { |
| const VkDevice device = m_context.getDevice(); |
| vector<VkAttachmentDescription> attachmentDescs; |
| for (deUint32 subpass = 0; subpass < 2; subpass ++) |
| { |
| for (deUint32 i = 0 ; i < m_subpasses[subpass].getInputAttachmentNum(); i++) |
| { |
| VkFormat format = attFormat; |
| if (i >= m_subpasses[subpass].getColorAttachmentNum()) |
| { |
| format = m_testCase->getDSFormat(); |
| } |
| attachmentDescs.push_back({ |
| 0, // VkAttachmentDescriptionFlags flags; |
| format, // VkFormat format; |
| m_subpasses[subpass].m_sampleCount, // VkSampleCountFlagBits samples; |
| VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp; |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; |
| VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp stencilLoadOp; |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp; |
| VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout; |
| VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout; |
| }); |
| } |
| } |
| |
| std::vector<VkSubpassDescription> subpasses(2, VkSubpassDescription{}); |
| |
| subpasses[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; |
| subpasses[0].inputAttachmentCount = m_subpasses[0].getInputAttachmentNum(); |
| subpasses[0].pInputAttachments = m_subpasses[0].m_attachmentReferences.data(); |
| subpasses[0].colorAttachmentCount = m_subpasses[0].getColorAttachmentNum(); |
| subpasses[0].pColorAttachments = m_subpasses[0].m_attachmentReferences.data(); |
| subpasses[0].pDepthStencilAttachment = m_subpasses[0].getDepthStencilAttachment(); |
| |
| subpasses[1].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; |
| subpasses[1].inputAttachmentCount = m_subpasses[0].getColorAttachmentNum(); |
| subpasses[1].pInputAttachments = m_subpasses[0].m_attachmentReferences.data(); |
| subpasses[1].colorAttachmentCount = m_subpasses[1].getColorAttachmentNum(); |
| subpasses[1].pColorAttachments = m_subpasses[1].m_attachmentReferences.data(); |
| |
| /* self dependency for subpass 0 and dependency from subpass 0 to 1 */ |
| vector<VkSubpassDependency> dependencies; |
| addDependency(dependencies, 0, 1, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT); |
| if (m_testCase->m_explicitSync) |
| { |
| addDependency(dependencies, 0, 0, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT); |
| if (m_testCase->hasDepthStencil()) |
| { |
| addDependency(dependencies, 0, 0, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT); |
| } |
| } |
| else |
| { |
| subpasses[0].flags = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM; |
| if (m_testCase->hasDepth()) |
| { |
| subpasses[0].flags |= VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM; |
| } |
| else if (m_testCase->hasStencil()) |
| { |
| subpasses[0].flags |= VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM; |
| } |
| } |
| |
| VkRenderPassCreateInfo renderPassCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; |
| NULL, // const void* pNext; |
| 0, // VkRenderPassCreateFlags flags; |
| (deUint32)attachmentDescs.size(), // uint32_t attachmentCount; |
| attachmentDescs.data(), // const VkAttachmentDescription* pAttachments; |
| (deUint32)subpasses.size(), // uint32_t subpassCount; |
| subpasses.data(), // const VkSubpassDescription* pSubpasses; |
| (deUint32)dependencies.size(), // uint32_t dependencyCount; |
| dependencies.data(), // const VkSubpassDependency* pDependencies; |
| }; |
| |
| return ::createRenderPass(m_vk, device, &renderPassCreateInfo); |
| } |
| |
| void AttachmentAccessOrderTestInstance::createVertexBuffer() |
| { |
| deUint32 primitiveNum = m_testCase->m_overlapPrimitives ? AttachmentAccessOrderTestCase::ELEM_NUM * 2: 2; |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| const VkDevice device = m_context.getDevice(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| std::vector<tcu::Vec2> vbo(3*primitiveNum); |
| for (deUint32 i=0; i < primitiveNum/2; i++) |
| { |
| vbo[i*6 + 0] = {-1, -1}; |
| vbo[i*6 + 1] = { 1, -1}; |
| vbo[i*6 + 2] = {-1, 1}; |
| vbo[i*6 + 3] = { 1, 1}; |
| vbo[i*6 + 4] = {-1, 1}; |
| vbo[i*6 + 5] = { 1, -1}; |
| } |
| |
| const size_t dataSize = vbo.size() * sizeof(tcu::Vec2); |
| { |
| const VkBufferCreateInfo vertexBufferParams = |
| { |
| VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkBufferCreateFlags flags; |
| dataSize, // VkDeviceSize size; |
| VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 1u, // deUint32 queueFamilyCount; |
| &queueFamilyIndex // const deUint32* pQueueFamilyIndices; |
| }; |
| m_vertexBuffer = createBuffer(m_vk, device, &vertexBufferParams); |
| m_vertexBufferMemory = allocator.allocate(getBufferMemoryRequirements(m_vk, device, *m_vertexBuffer), MemoryRequirement::HostVisible); |
| |
| VK_CHECK(m_vk.bindBufferMemory(device, *m_vertexBuffer, m_vertexBufferMemory->getMemory(), m_vertexBufferMemory->getOffset())); |
| } |
| |
| /* Load vertices into vertex buffer */ |
| deMemcpy(m_vertexBufferMemory->getHostPtr(), vbo.data(), dataSize); |
| flushAlloc(m_vk, device, *m_vertexBufferMemory); |
| } |
| |
| void AttachmentAccessOrderTestInstance::createResultBuffer() |
| { |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| const VkDevice device = m_context.getDevice(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| /* result buffer */ |
| const VkBufferCreateInfo resultBufferInfo = |
| { |
| VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkBufferCreateFlags flags; |
| WIDTH * HEIGHT * sizeof(tcu::UVec2), // VkDeviceSize size; |
| VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 1u, // deUint32 queueFamilyCount; |
| &queueFamilyIndex // const deUint32* pQueueFamilyIndices; |
| }; |
| m_resultBuffer = createBuffer(m_vk, device, &resultBufferInfo); |
| m_resultBufferMemory = allocator.allocate( getBufferMemoryRequirements(m_vk, device, *m_resultBuffer), MemoryRequirement::HostVisible); |
| |
| VK_CHECK(m_vk.bindBufferMemory(device, *m_resultBuffer, m_resultBufferMemory->getMemory(), m_resultBufferMemory->getOffset())); |
| } |
| |
| AttachmentAccessOrderTestInstance::AttachmentAccessOrderTestInstance( Context& context, const AttachmentAccessOrderTestCase *testCase) |
| : TestInstance(context) |
| , m_testCase (testCase) |
| , m_vk (m_context.getDeviceInterface()) |
| , m_subpasses(2) |
| { |
| const VkDevice device = m_context.getDevice(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| |
| m_descSetLayout = makeDescriptorSetLayout(m_vk, device, m_testCase->getInputAttachmentNum()); |
| |
| m_descPool = DescriptorPoolBuilder().addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, m_testCase->getInputAttachmentNum()) |
| .build(m_vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); |
| |
| m_descSet = makeDescriptorSet(m_vk, device, *m_descPool, *m_descSetLayout, nullptr); |
| |
| vector<VkImageView> attachmentHandles; |
| VkDescriptorSetLayout dsetLayout = *m_descSetLayout; |
| |
| m_subpasses[0].createAttachments( 0, m_testCase->getInputAttachmentNum(), m_testCase->getColorAttachmentNum(), m_testCase->m_sampleCount, |
| m_context, attachmentHandles, &dsetLayout, m_testCase); |
| m_subpasses[1].createAttachments(1, 1, 1, VK_SAMPLE_COUNT_1_BIT, m_context, attachmentHandles, &dsetLayout, m_testCase); |
| |
| m_sampler = makeSampler(m_vk, device); |
| |
| writeDescriptorSets(); |
| m_renderPass = createRenderPass(m_testCase->getColorFormat()); |
| |
| m_framebuffer = makeFramebuffer(m_vk, device, *m_renderPass, (deUint32)attachmentHandles.size(), attachmentHandles.data(), WIDTH, HEIGHT, 1); |
| |
| m_subpasses[0].createPipeline(*m_renderPass, m_context); |
| m_subpasses[1].createPipeline(*m_renderPass, m_context); |
| |
| createVertexBuffer(); |
| |
| createResultBuffer(); |
| |
| m_cmdPool = createCommandPool(m_vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); |
| m_cmdBuffer = allocateCommandBuffer(m_vk, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); |
| } |
| |
| AttachmentAccessOrderTestInstance::~AttachmentAccessOrderTestInstance (void) |
| { |
| } |
| |
| void AttachmentAccessOrderTestInstance::addPipelineBarrier( VkCommandBuffer cmdBuffer, |
| VkImage image, |
| VkImageLayout oldLayout, |
| VkImageLayout newLayout, |
| VkAccessFlags srcAccessMask, |
| VkAccessFlags dstAccessMask, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkImageAspectFlags aspect) |
| { |
| VkImageMemoryBarrier barrier = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| srcAccessMask, // VkAccessFlags srcAccessMask; |
| dstAccessMask, // VkAccessFlags dstAccessMask; |
| oldLayout, // VkImageLayout oldLayout; |
| newLayout, // VkImageLayout newLayout; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex; |
| image, // VkImage image; |
| { |
| aspect, //VkImageAspectFlags aspectMask; |
| 0u, //uint32_t baseMipLevel; |
| 1u, //uint32_t levelCount; |
| 0u, //uint32_t baseArrayLayer; |
| 1u, //uint32_t layerCount; |
| }, // VkImageSubresourceRange subresourceRange; |
| }; |
| |
| m_vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, dstStageMask, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, |
| 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); |
| } |
| void AttachmentAccessOrderTestInstance::addClearColor(VkCommandBuffer cmdBuffer, VkImage image) |
| { |
| VkClearColorValue clearColor; |
| clearColor.float32[0] = 0.0; |
| clearColor.float32[1] = 0.0; |
| clearColor.float32[2] = 0.0; |
| clearColor.float32[3] = 1.0; |
| |
| const VkImageSubresourceRange subresourceRange = |
| { |
| VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask; |
| 0u, //uint32_t baseMipLevel; |
| 1u, //uint32_t levelCount; |
| 0u, //uint32_t baseArrayLayer; |
| 1u, //uint32_t layerCount; |
| }; |
| |
| m_vk.cmdClearColorImage(cmdBuffer, image, VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRange); |
| } |
| |
| void AttachmentAccessOrderTestInstance::addClearDepthStencil(VkCommandBuffer cmdBuffer, VkImage image) |
| { |
| VkClearDepthStencilValue clearValue; |
| clearValue.depth = 0.0; |
| clearValue.stencil = 0; |
| |
| const VkImageSubresourceRange subresourceRange = |
| { |
| VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, //VkImageAspectFlags aspectMask; |
| 0u, //uint32_t baseMipLevel; |
| 1u, //uint32_t levelCount; |
| 0u, //uint32_t baseArrayLayer; |
| 1u, //uint32_t layerCount; |
| }; |
| |
| m_vk.cmdClearDepthStencilImage(cmdBuffer, image, VK_IMAGE_LAYOUT_GENERAL, &clearValue, 1, &subresourceRange); |
| } |
| |
| |
| tcu::TestStatus AttachmentAccessOrderTestInstance::iterate (void) |
| { |
| const VkQueue queue = m_context.getUniversalQueue(); |
| const VkDevice device = m_context.getDevice(); |
| |
| beginCommandBuffer(m_vk, *m_cmdBuffer, 0u); |
| |
| for (deUint32 i=0; i < m_subpasses.size(); i++) |
| { |
| for (deUint32 j=0; j < m_subpasses[i].getColorAttachmentNum(); j++) |
| { |
| addPipelineBarrier( *m_cmdBuffer, *m_subpasses[i].m_inputAtt[j], VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, |
| 0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); |
| |
| addClearColor( *m_cmdBuffer, *m_subpasses[i].m_inputAtt[j]); |
| } |
| for (deUint32 j=m_subpasses[i].getColorAttachmentNum(); j < m_subpasses[i].getInputAttachmentNum(); j++) |
| { |
| addPipelineBarrier( *m_cmdBuffer, *m_subpasses[i].m_inputAtt[j], VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, |
| 0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, |
| VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); |
| addClearDepthStencil( *m_cmdBuffer, *m_subpasses[i].m_inputAtt[j]); |
| } |
| } |
| |
| const VkMemoryBarrier memBarrier = |
| { |
| VK_STRUCTURE_TYPE_MEMORY_BARRIER, |
| DE_NULL, |
| VK_ACCESS_TRANSFER_WRITE_BIT, |
| VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
| }; |
| |
| m_vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, |
| 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL); |
| |
| const VkRect2D renderArea = makeRect2D(WIDTH, HEIGHT); |
| beginRenderPass(m_vk, *m_cmdBuffer, *m_renderPass, *m_framebuffer, renderArea); |
| |
| const VkDeviceSize vertexBufferOffset = 0; |
| const VkBuffer vertexBuffer = *m_vertexBuffer; |
| |
| m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset); |
| m_vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_subpasses[0].m_pipeline); |
| VkDescriptorSet dset = *m_descSet; |
| m_vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_subpasses[0].m_pipelineLayout, 0, 1, &dset, 0, DE_NULL); |
| |
| deUint32 numDraws = m_testCase->m_overlapDraws ? AttachmentAccessOrderTestCase::ELEM_NUM : 1; |
| deUint32 numPrimitives = m_testCase->m_overlapPrimitives ? 2 * AttachmentAccessOrderTestCase::ELEM_NUM : 2; |
| deUint32 numInstances = m_testCase->m_overlapInstances ? AttachmentAccessOrderTestCase::ELEM_NUM : 1; |
| |
| for (deUint32 i=0; i < numDraws; i++) |
| { |
| m_vk.cmdPushConstants( *m_cmdBuffer, *m_subpasses[0].m_pipelineLayout, |
| VK_SHADER_STAGE_FRAGMENT_BIT | (m_testCase->hasDepthStencil() ? VK_SHADER_STAGE_VERTEX_BIT : 0), |
| 0, 4, &i); |
| for (deUint32 j = 0; m_testCase->m_explicitSync && i != 0 && j < m_subpasses[0].getColorAttachmentNum(); j++) |
| { |
| addPipelineBarrier( *m_cmdBuffer, *m_subpasses[0].m_inputAtt[j], VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, |
| VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); |
| } |
| for (deUint32 j = m_subpasses[0].getColorAttachmentNum(); m_testCase->m_explicitSync && i != 0 && j < m_subpasses[0].getInputAttachmentNum(); j++) |
| { |
| addPipelineBarrier( *m_cmdBuffer, *m_subpasses[0].m_inputAtt[j], VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, |
| VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, |
| VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, |
| VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
| VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); |
| } |
| m_vk.cmdDraw(*m_cmdBuffer, numPrimitives * 3, numInstances, 0, 0); |
| } |
| |
| |
| m_vk.cmdNextSubpass(*m_cmdBuffer, VK_SUBPASS_CONTENTS_INLINE); |
| |
| m_vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_subpasses[1].m_pipeline); |
| |
| m_vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_subpasses[1].m_pipelineLayout, 0, 1, &dset, 0, DE_NULL); |
| |
| m_vk.cmdDraw(*m_cmdBuffer, 6, 1, 0, 0); |
| |
| endRenderPass(m_vk, *m_cmdBuffer); |
| |
| copyImageToBuffer( m_vk, *m_cmdBuffer, *m_subpasses[1].m_inputAtt[0], *m_resultBuffer, tcu::IVec2(WIDTH, HEIGHT), VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, |
| VK_IMAGE_LAYOUT_GENERAL); |
| |
| endCommandBuffer(m_vk, *m_cmdBuffer); |
| |
| submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get()); |
| |
| return validateResults(numDraws, numPrimitives, numInstances); |
| } |
| |
| tcu::TestStatus AttachmentAccessOrderTestInstance::validateResults(deUint32 numDraws, deUint32 numPrimitives, deUint32 numInstances) |
| { |
| const VkDevice device = m_context.getDevice(); |
| qpTestResult res = QP_TEST_RESULT_PASS; |
| |
| invalidateAlloc(m_vk, device, *m_resultBufferMemory); |
| if (m_testCase->m_integerFormat) |
| { |
| tcu::UVec2 *resBuf = static_cast<tcu::UVec2 *> (m_resultBufferMemory->getHostPtr()); |
| |
| for (deUint32 y = 0; y < HEIGHT && res == QP_TEST_RESULT_PASS; y ++) |
| { |
| for (deUint32 x = 0; x < WIDTH && res == QP_TEST_RESULT_PASS; x ++) |
| { |
| tcu::UVec2 pixel = resBuf[y * WIDTH + x]; |
| if (pixel[0] != 0 || pixel[1] != numDraws * numPrimitives/2 * numInstances) |
| { |
| res = QP_TEST_RESULT_FAIL; |
| } |
| } |
| } |
| } |
| else |
| { |
| tcu::Vec2 *resBuf = static_cast<tcu::Vec2 *> (m_resultBufferMemory->getHostPtr()); |
| |
| for (deUint32 y = 0; y < HEIGHT && res == QP_TEST_RESULT_PASS; y ++) |
| { |
| for (deUint32 x = 0; x < WIDTH && res == QP_TEST_RESULT_PASS; x ++) |
| { |
| tcu::Vec2 pixel = resBuf[y * WIDTH + x]; |
| if (pixel[0] != 0 || pixel[1] != (float)(numDraws * numPrimitives/2 * numInstances)) |
| { |
| res = QP_TEST_RESULT_FAIL; |
| } |
| } |
| } |
| } |
| |
| return tcu::TestStatus(res, qpGetTestResultName(res)); |
| } |
| |
| |
| } // anonymous ns |
| |
| |
| static void createRasterizationOrderAttachmentAccessTestVariations( tcu::TestContext& testCtx, tcu::TestCaseGroup *gr, |
| const string &prefix_name, const string &prefix_desc, |
| deUint32 inputNum, bool integerFormat, bool depth, bool stencil) |
| { |
| const struct |
| { |
| const std::string name; |
| const std::string description; |
| bool explicitSync; |
| bool overlapDraws; |
| bool overlapPrimitives; |
| bool overlapInstances; |
| } leafTestCreateParams[] = |
| { |
| { "multi_draw_barriers", "Basic test with overlapping draw commands with barriers", true, true, false, false, }, |
| { "multi_draw", "Test with overlapping draw commands without barriers", false, true, false, false, }, |
| { "multi_primitives", "Test with a draw command with overlapping primitives", false, false, true, false, }, |
| { "multi_instances", "Test with a draw command with overlapping instances", false, false, false, true, }, |
| { "all", "Test with overlapping draw commands, each with overlapping primitives and instances", false, true, true, true, }, |
| }; |
| constexpr deUint32 leafTestCreateParamsNum = sizeof(leafTestCreateParams) / sizeof(leafTestCreateParams[0]); |
| |
| VkSampleCountFlagBits sampleCountValues[] = |
| { |
| VK_SAMPLE_COUNT_1_BIT, |
| VK_SAMPLE_COUNT_2_BIT, |
| VK_SAMPLE_COUNT_4_BIT, |
| VK_SAMPLE_COUNT_8_BIT, |
| VK_SAMPLE_COUNT_16_BIT, |
| VK_SAMPLE_COUNT_32_BIT, |
| VK_SAMPLE_COUNT_64_BIT, |
| }; |
| constexpr deUint32 sampleCountValuesNum = sizeof(sampleCountValues) / sizeof(sampleCountValues[0]); |
| |
| for (deUint32 i = 0; i < sampleCountValuesNum ; i++) |
| { |
| stringstream name; |
| stringstream desc; |
| name << prefix_name << "samples_" << AttachmentAccessOrderTestCase::getSampleNum(sampleCountValues[i]); |
| desc << prefix_desc << AttachmentAccessOrderTestCase::getSampleNum(sampleCountValues[i]) << " samples per pixel"; |
| tcu::TestCaseGroup *subgr = new tcu::TestCaseGroup(testCtx, name.str().c_str(), desc.str().c_str()); |
| |
| for (deUint32 k = 0; k < leafTestCreateParamsNum; k++) |
| { |
| if (depth) |
| { |
| subgr->addChild(new AttachmentAccessOrderDepthTestCase( testCtx, leafTestCreateParams[k].name, |
| leafTestCreateParams[k].description, |
| leafTestCreateParams[k].explicitSync, |
| leafTestCreateParams[k].overlapDraws, |
| leafTestCreateParams[k].overlapPrimitives, |
| leafTestCreateParams[k].overlapInstances, |
| sampleCountValues[i])); |
| } |
| else if (stencil) |
| { |
| subgr->addChild(new AttachmentAccessOrderStencilTestCase( testCtx, leafTestCreateParams[k].name, |
| leafTestCreateParams[k].description, |
| leafTestCreateParams[k].explicitSync, |
| leafTestCreateParams[k].overlapDraws, |
| leafTestCreateParams[k].overlapPrimitives, |
| leafTestCreateParams[k].overlapInstances, |
| sampleCountValues[i])); |
| } |
| else |
| { |
| subgr->addChild(new AttachmentAccessOrderColorTestCase( testCtx, leafTestCreateParams[k].name, |
| leafTestCreateParams[k].description, |
| leafTestCreateParams[k].explicitSync, |
| leafTestCreateParams[k].overlapDraws, |
| leafTestCreateParams[k].overlapPrimitives, |
| leafTestCreateParams[k].overlapInstances, |
| sampleCountValues[i], inputNum, integerFormat)); |
| } |
| } |
| gr->addChild(subgr); |
| } |
| } |
| |
| static void createRasterizationOrderAttachmentAccessFormatTests(tcu::TestContext& testCtx, tcu::TestCaseGroup *gr, bool integerFormat) |
| { |
| const deUint32 inputNum[] = {1, 4, 8}; |
| const deUint32 inputNumSize = sizeof(inputNum) / sizeof(inputNum[0]); |
| |
| tcu::TestCaseGroup *formatGr; |
| |
| if (integerFormat) |
| { |
| formatGr = new tcu::TestCaseGroup(testCtx, "format_integer", "Tests with an integer format" ); |
| } |
| else |
| { |
| formatGr = new tcu::TestCaseGroup(testCtx, "format_float", "Tests with an float format" ); |
| } |
| |
| for (deUint32 i = 0; i < inputNumSize; i++) |
| { |
| stringstream numName; |
| stringstream numDesc; |
| numName << "attachments_" << inputNum[i] << "_"; |
| numDesc << "Tests with " << inputNum[i] << " attachments and "; |
| createRasterizationOrderAttachmentAccessTestVariations(testCtx, formatGr, numName.str(), numDesc.str(), inputNum[i], integerFormat, false, false); |
| } |
| gr->addChild(formatGr); |
| } |
| |
| tcu::TestCaseGroup* createRasterizationOrderAttachmentAccessTests(tcu::TestContext& testCtx) |
| { |
| /* Add the color tests */ |
| tcu::TestCaseGroup *gr = new tcu::TestCaseGroup(testCtx, "rasterization_order_attachment_access", "Rasterization Order Attachment access tests"); |
| createRasterizationOrderAttachmentAccessFormatTests(testCtx, gr, false); |
| createRasterizationOrderAttachmentAccessFormatTests(testCtx, gr, true); |
| |
| /* Add the D/S tests */ |
| tcu::TestCaseGroup *depth_gr = new tcu::TestCaseGroup(testCtx, "depth", "Tests depth rasterization order" ); |
| tcu::TestCaseGroup *stencil_gr = new tcu::TestCaseGroup(testCtx, "stencil", "Tests stencil rasterization order" ); |
| string name_prefix = ""; |
| string desc_prefix = "Tests with "; |
| createRasterizationOrderAttachmentAccessTestVariations(testCtx, depth_gr, name_prefix, desc_prefix, 1, false, true, false); |
| createRasterizationOrderAttachmentAccessTestVariations(testCtx, stencil_gr, name_prefix, desc_prefix, 1, false, false, true); |
| gr->addChild(depth_gr); |
| gr->addChild(stencil_gr); |
| |
| return gr; |
| } |
| |
| } // rasterization |
| } // vkt |
