vulkan/mesh_shader/vktMeshShaderConditionalRenderingTestsEXT.cpp

/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2022 The Khronos Group Inc.
 * Copyright (c) 2022 Valve Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Tests using VK_EXT_mesh_shader and VK_EXT_conditional_rendering
 *//*--------------------------------------------------------------------*/

#include "vktMeshShaderConditionalRenderingTestsEXT.hpp"
#include "vktMeshShaderUtil.hpp"
#include "vktTestCase.hpp"

#include "vkObjUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkCmdUtil.hpp"
#include "vkBarrierUtil.hpp"

#include "tcuVector.hpp"
#include "tcuImageCompare.hpp"

#include <vector>
#include <sstream>
#include <memory>

namespace vkt
{
namespace MeshShader
{

namespace
{

using namespace vk;

using GroupPtr = de::MovePtr<tcu::TestCaseGroup>;

enum class DrawType
{
    DRAW,
    DRAW_INDIRECT,
    DRAW_INDIRECT_WITH_COUNT,
};

enum class CmdBufferType
{
    PRIMARY,
    SECONDARY,
    SECONDARY_WITH_INHERITANCE,
};

static constexpr VkDeviceSize kBindOffset = 16u;

std::vector<uint32_t> getCondValues(void)
{
    const std::vector<uint32_t> values = {
        0x01000000u, 0x00010000u, 0x00000100u, 0x00000001u, 0x00000000u,
    };

    return values;
}

std::string paddedHex(uint32_t value)
{
    std::ostringstream repr;
    repr << "0x" << std::hex << std::setw(8u) << std::setfill('0') << value;
    return repr.str();
}

tcu::Vec4 getOutputColor(void)
{
    return tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
}

tcu::Vec4 getClearColor(void)
{
    return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
}

struct TestParams
{
    DrawType drawType;
    CmdBufferType cmdBufferType;
    bool bindWithOffset;
    bool condWithOffset;
    uint32_t condValue;
    bool inverted;
    bool useTask;

    bool needsSecondaryCmdBuffer(void) const
    {
        return (cmdBufferType != CmdBufferType::PRIMARY);
    }
};

class ConditionalRenderingCase : public vkt::TestCase
{
public:
    ConditionalRenderingCase(tcu::TestContext &testCtx, const std::string &name, const TestParams &params)
        : vkt::TestCase(testCtx, name)
        , m_params(params)
    {
    }
    virtual ~ConditionalRenderingCase(void)
    {
    }

    void initPrograms(vk::SourceCollections &programCollection) const override;
    TestInstance *createInstance(Context &context) const override;
    void checkSupport(Context &context) const override;

protected:
    const TestParams m_params;
};

class ConditionBuffer
{
public:
    ConditionBuffer(const DeviceInterface &vkd, VkDevice device, Allocator &alloc, uint32_t condValue,
                    bool bindWithOffset, bool condWithOffset)
        : m_buffer()
        , m_allocation()
        , m_condOffset(0ull)
    {
        // Create buffer with the desired size first.
        const auto condSize         = static_cast<VkDeviceSize>(sizeof(condValue));
        const auto condOffset       = (condWithOffset ? condSize : 0ull);
        const auto bufferSize       = condSize + condOffset;
        const auto bufferCreateInfo = makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT);
        auto buffer                 = createBuffer(vkd, device, &bufferCreateInfo);

        // Allocate memory taking bindWithOffset into account.
        const auto bufferMemReqs = getBufferMemoryRequirements(vkd, device, buffer.get());
        const auto bindOffset    = (bindWithOffset ? de::roundUp(kBindOffset, bufferMemReqs.alignment) : 0ull);
        const auto allocSize     = bufferMemReqs.size + bindOffset;

        const auto actualMemReqs =
            makeMemoryRequirements(allocSize, bufferMemReqs.alignment, bufferMemReqs.memoryTypeBits);
        auto allocation = alloc.allocate(actualMemReqs, MemoryRequirement::HostVisible);
        vkd.bindBufferMemory(device, buffer.get(), allocation->getMemory(), bindOffset);

        // Fill buffer data.
        const uint32_t fillValue = ((condValue != 0u) ? 0u : 1u);
        uint8_t *hostPtr         = reinterpret_cast<uint8_t *>(allocation->getHostPtr());

        deMemset(hostPtr, 0, static_cast<size_t>(actualMemReqs.size));
        deMemcpy(hostPtr + bindOffset, &fillValue, sizeof(fillValue));
        deMemcpy(hostPtr + bindOffset + condOffset, &condValue, sizeof(condValue));

        m_buffer     = buffer;
        m_allocation = allocation;
        m_condOffset = condOffset;
    }

    VkDeviceSize getCondOffset(void) const
    {
        return m_condOffset;
    }

    VkBuffer getBuffer(void) const
    {
        return m_buffer.get();
    }

    // Cannot copy or assign this.
    ConditionBuffer(const ConditionBuffer &)            = delete;
    ConditionBuffer &operator=(const ConditionBuffer &) = delete;

protected:
    Move<VkBuffer> m_buffer;
    de::MovePtr<Allocation> m_allocation;
    VkDeviceSize m_condOffset;
};

class ConditionalRenderingInstance : public vkt::TestInstance
{
public:
    ConditionalRenderingInstance(Context &context, const TestParams &params)
        : vkt::TestInstance(context)
        , m_params(params)
        , m_conditionBuffer()
        , m_indirectDrawArgsBuffer()
        , m_indirectDrawCountBuffer()
    {
    }
    virtual ~ConditionalRenderingInstance(void)
    {
    }

    tcu::TestStatus iterate(void) override;

protected:
    // Creates the indirect buffers that are needed according to the test parameters.
    void initIndirectBuffers(const DeviceInterface &vkd, const VkDevice device, Allocator &alloc);

    // Calls the appropriate drawing command depending on the test parameters.
    void drawMeshTasks(const DeviceInterface &vkd, const VkCommandBuffer cmdBuffer) const;

    const TestParams m_params;
    std::unique_ptr<ConditionBuffer> m_conditionBuffer;
    std::unique_ptr<BufferWithMemory> m_indirectDrawArgsBuffer;
    std::unique_ptr<BufferWithMemory> m_indirectDrawCountBuffer;
};

// Makes an indirect buffer with the specified contents.
template <class T>
std::unique_ptr<BufferWithMemory> makeIndirectBuffer(const DeviceInterface &vkd, const VkDevice device,
                                                     Allocator &alloc, const T &data)
{
    const auto bufferSize       = static_cast<VkDeviceSize>(sizeof(data));
    const auto bufferCreateInfo = makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT);

    std::unique_ptr<BufferWithMemory> buffer(
        new BufferWithMemory(vkd, device, alloc, bufferCreateInfo, MemoryRequirement::HostVisible));

    auto &allocation = buffer->getAllocation();
    void *dataPtr    = allocation.getHostPtr();

    deMemcpy(dataPtr, &data, sizeof(data));
    flushAlloc(vkd, device, allocation);

    return buffer;
}

void ConditionalRenderingInstance::initIndirectBuffers(const DeviceInterface &vkd, const VkDevice device,
                                                       Allocator &alloc)
{
    if (m_params.drawType != DrawType::DRAW)
    {
        const VkDrawMeshTasksIndirectCommandEXT drawArgs = {1u, 1u, 1u};
        m_indirectDrawArgsBuffer                         = makeIndirectBuffer(vkd, device, alloc, drawArgs);
    }

    if (m_params.drawType == DrawType::DRAW_INDIRECT_WITH_COUNT)
    {
        const uint32_t drawCount  = 1u;
        m_indirectDrawCountBuffer = makeIndirectBuffer(vkd, device, alloc, drawCount);
    }
}

void ConditionalRenderingInstance::drawMeshTasks(const DeviceInterface &vkd, const VkCommandBuffer cmdBuffer) const
{
    const auto stride = static_cast<uint32_t>(sizeof(VkDrawMeshTasksIndirectCommandEXT));

    if (m_params.drawType == DrawType::DRAW)
    {
        vkd.cmdDrawMeshTasksEXT(cmdBuffer, 1u, 1u, 1u);
    }
    else if (m_params.drawType == DrawType::DRAW_INDIRECT)
    {
        vkd.cmdDrawMeshTasksIndirectEXT(cmdBuffer, m_indirectDrawArgsBuffer->get(), 0ull, 1u, stride);
    }
    else if (m_params.drawType == DrawType::DRAW_INDIRECT_WITH_COUNT)
    {
        vkd.cmdDrawMeshTasksIndirectCountEXT(cmdBuffer, m_indirectDrawArgsBuffer->get(), 0ull,
                                             m_indirectDrawCountBuffer->get(), 0ull, 1u, stride);
    }
    else
        DE_ASSERT(false);
}

void ConditionalRenderingCase::initPrograms(vk::SourceCollections &programCollection) const
{
    const auto buildOptions = getMinMeshEXTBuildOptions(programCollection.usedVulkanVersion);

    if (m_params.useTask)
    {
        std::ostringstream task;
        task << "#version 460\n"
             << "#extension GL_EXT_mesh_shader : enable\n"
             << "\n"
             << "layout (local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
             << "\n"
             << "void main (void) {\n"
             << "    EmitMeshTasksEXT(1u, 1u, 1u);\n"
             << "}\n";
        programCollection.glslSources.add("task") << glu::TaskSource(task.str()) << buildOptions;
    }

    std::ostringstream mesh;
    mesh << "#version 460\n"
         << "#extension GL_EXT_mesh_shader : enable\n"
         << "\n"
         << "layout (local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
         << "layout (triangles) out;\n"
         << "layout (max_vertices=3, max_primitives=1) out;\n"
         << "\n"
         << "void main (void) {\n"
         << "    SetMeshOutputsEXT(3u, 1u);\n"
         << "\n"
         << "    gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0u, 1u, 2u);\n"
         << "\n"
         << "    gl_MeshVerticesEXT[0].gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
         << "    gl_MeshVerticesEXT[1].gl_Position = vec4(-1.0,  3.0, 0.0, 1.0);\n"
         << "    gl_MeshVerticesEXT[2].gl_Position = vec4( 3.0, -1.0, 0.0, 1.0);\n"
         << "}\n";
    programCollection.glslSources.add("mesh") << glu::MeshSource(mesh.str()) << buildOptions;

    const auto outColor = getOutputColor();
    std::ostringstream frag;
    frag << "#version 460\n"
         << "\n"
         << "layout (location=0) out vec4 outColor;\n"
         << "\n"
         << "void main (void) {\n"
         << "    outColor = vec4" << outColor << ";\n"
         << "}\n";
    programCollection.glslSources.add("frag") << glu::FragmentSource(frag.str());
}

TestInstance *ConditionalRenderingCase::createInstance(Context &context) const
{
    return new ConditionalRenderingInstance(context, m_params);
}

void ConditionalRenderingCase::checkSupport(Context &context) const
{
    checkTaskMeshShaderSupportEXT(context, m_params.useTask /*requireTask*/, true /*requireMesh*/);

    context.requireDeviceFunctionality("VK_EXT_conditional_rendering");

    if (m_params.drawType == DrawType::DRAW_INDIRECT_WITH_COUNT)
        context.requireDeviceFunctionality("VK_KHR_draw_indirect_count");

    if (m_params.cmdBufferType == CmdBufferType::SECONDARY_WITH_INHERITANCE)
    {
        const auto &condRenderingFeatures = context.getConditionalRenderingFeaturesEXT();
        if (!condRenderingFeatures.inheritedConditionalRendering)
            TCU_THROW(NotSupportedError, "inheritedConditionalRendering not supported");
    }
}

tcu::TestStatus ConditionalRenderingInstance::iterate()
{
    const auto &vkd       = m_context.getDeviceInterface();
    const auto device     = m_context.getDevice();
    auto &alloc           = m_context.getDefaultAllocator();
    const auto queueIndex = m_context.getUniversalQueueFamilyIndex();
    const auto queue      = m_context.getUniversalQueue();

    const auto colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
    const auto colorUsage  = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
    const auto tcuFormat   = mapVkFormat(colorFormat);
    const auto colorExtent = makeExtent3D(4u, 4u, 1u);
    const tcu::IVec3 iExtent3D(static_cast<int>(colorExtent.width), static_cast<int>(colorExtent.height),
                               static_cast<int>(colorExtent.depth));
    const auto clearColor  = getClearColor();
    const auto drawColor   = getOutputColor();
    const auto bindPoint   = VK_PIPELINE_BIND_POINT_GRAPHICS;
    const auto needsSecCmd = m_params.needsSecondaryCmdBuffer();

    // Create color attachment.
    const VkImageCreateInfo colorAttCreateInfo = {
        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
        nullptr,                             // const void* pNext;
        0u,                                  // VkImageCreateFlags flags;
        VK_IMAGE_TYPE_2D,                    // VkImageType imageType;
        colorFormat,                         // VkFormat format;
        colorExtent,                         // VkExtent3D extent;
        1u,                                  // uint32_t mipLevels;
        1u,                                  // uint32_t arrayLayers;
        VK_SAMPLE_COUNT_1_BIT,               // VkSampleCountFlagBits samples;
        VK_IMAGE_TILING_OPTIMAL,             // VkImageTiling tiling;
        colorUsage,                          // VkImageUsageFlags usage;
        VK_SHARING_MODE_EXCLUSIVE,           // VkSharingMode sharingMode;
        0u,                                  // uint32_t queueFamilyIndexCount;
        nullptr,                             // const uint32_t* pQueueFamilyIndices;
        VK_IMAGE_LAYOUT_UNDEFINED,           // VkImageLayout initialLayout;
    };
    ImageWithMemory colorAtt(vkd, device, alloc, colorAttCreateInfo, MemoryRequirement::Any);
    const auto colorSRR     = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
    const auto colorSRL     = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
    const auto colorAttView = makeImageView(vkd, device, colorAtt.get(), VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorSRR);

    // Render pass and framebuffer.
    const auto renderPass = makeRenderPass(vkd, device, colorFormat);
    const auto framebuffer =
        makeFramebuffer(vkd, device, renderPass.get(), colorAttView.get(), colorExtent.width, colorExtent.height);

    // Verification buffer.
    const auto verifBufferSize =
        static_cast<VkDeviceSize>(tcu::getPixelSize(tcuFormat) * iExtent3D.x() * iExtent3D.y() * iExtent3D.z());
    const auto verifBufferCreateInfo = makeBufferCreateInfo(verifBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
    BufferWithMemory verifBuffer(vkd, device, alloc, verifBufferCreateInfo, MemoryRequirement::HostVisible);
    auto &verifBufferAlloc = verifBuffer.getAllocation();
    void *verifBufferData  = verifBufferAlloc.getHostPtr();

    // Create the condition buffer.
    m_conditionBuffer.reset(
        new ConditionBuffer(vkd, device, alloc, m_params.condValue, m_params.bindWithOffset, m_params.condWithOffset));

    // Create the indirect buffers if needed.
    initIndirectBuffers(vkd, device, alloc);

    // Pipeline.
    const auto pipelineLayout = makePipelineLayout(vkd, device);
    const auto &binaries      = m_context.getBinaryCollection();
    const auto taskModule =
        (binaries.contains("task") ? createShaderModule(vkd, device, binaries.get("task")) : Move<VkShaderModule>());
    const auto meshModule = createShaderModule(vkd, device, binaries.get("mesh"));
    const auto fragModule = createShaderModule(vkd, device, binaries.get("frag"));

    const std::vector<VkViewport> viewports(1u, makeViewport(colorExtent));
    const std::vector<VkRect2D> scissors(1u, makeRect2D(colorExtent));

    const auto pipeline = makeGraphicsPipeline(vkd, device, pipelineLayout.get(), taskModule.get(), meshModule.get(),
                                               fragModule.get(), renderPass.get(), viewports, scissors);

    // Command pool and command buffers.
    const auto cmdPool          = makeCommandPool(vkd, device, queueIndex);
    const auto primaryCmdBuffer = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
    const auto secondaryCmdBuffer =
        (needsSecCmd ? allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_SECONDARY) :
                       Move<VkCommandBuffer>());
    const auto primary   = primaryCmdBuffer.get();
    const auto secondary = secondaryCmdBuffer.get();

    // Common conditional rendering begin info.
    const auto conditionalRenderingFlags =
        (m_params.inverted ? (VkConditionalRenderingFlagsEXT)VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT :
                             static_cast<VkConditionalRenderingFlagsEXT>(0));
    const VkConditionalRenderingBeginInfoEXT conditionalRenderingBegin = {
        VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, // VkStructureType sType;
        nullptr,                                                // const void* pNext;
        m_conditionBuffer->getBuffer(),                         // VkBuffer buffer;
        m_conditionBuffer->getCondOffset(),                     // VkDeviceSize offset;
        conditionalRenderingFlags,                              // VkConditionalRenderingFlagsEXT flags;
    };

    // Inheritance info for the secondary command buffer.
    const auto conditionalRenderingEnable =
        ((m_params.cmdBufferType == CmdBufferType::SECONDARY_WITH_INHERITANCE) ? VK_TRUE : VK_FALSE);
    const vk::VkCommandBufferInheritanceConditionalRenderingInfoEXT conditionalRenderingInheritanceInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, // VkStructureType sType;
        nullptr,                                                                     // const void* pNext;
        conditionalRenderingEnable, // VkBool32 conditionalRenderingEnable;
    };

    const VkCommandBufferInheritanceInfo inheritanceInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, // VkStructureType sType;
        &conditionalRenderingInheritanceInfo,              // const void* pNext;
        renderPass.get(),                                  // VkRenderPass renderPass;
        0u,                                                // uint32_t subpass;
        framebuffer.get(),                                 // VkFramebuffer framebuffer;
        VK_FALSE,                                          // VkBool32 occlusionQueryEnable;
        0u,                                                // VkQueryControlFlags queryFlags;
        0u,                                                // VkQueryPipelineStatisticFlags pipelineStatistics;
    };

    const VkCommandBufferUsageFlags cmdBufferUsageFlags =
        (VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
    const VkCommandBufferBeginInfo secondaryBeginInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
        nullptr,                                     // const void* pNext;
        cmdBufferUsageFlags,                         // VkCommandBufferUsageFlags flags;
        &inheritanceInfo,                            // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
    };

    beginCommandBuffer(vkd, primary);

    if (m_params.cmdBufferType == CmdBufferType::PRIMARY)
    {
        // Do everything in the primary command buffer.
        const auto cmdBuffer = primary;

        vkd.cmdBeginConditionalRenderingEXT(cmdBuffer, &conditionalRenderingBegin);
        beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), scissors.at(0u), clearColor);
        vkd.cmdBindPipeline(cmdBuffer, bindPoint, pipeline.get());
        drawMeshTasks(vkd, cmdBuffer);
        endRenderPass(vkd, cmdBuffer);
        vkd.cmdEndConditionalRenderingEXT(cmdBuffer);
    }
    else if (m_params.cmdBufferType == CmdBufferType::SECONDARY)
    {
        // Do everything in the secondary command buffer.
        // In addition, do the conditional rendering inside the render pass so it's a bit different from the primary case.
        beginRenderPass(vkd, primary, renderPass.get(), framebuffer.get(), scissors.at(0u), clearColor,
                        VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);

        const auto cmdBuffer = secondaryCmdBuffer.get();

        vkd.beginCommandBuffer(secondary, &secondaryBeginInfo);
        vkd.cmdBindPipeline(cmdBuffer, bindPoint, pipeline.get());
        vkd.cmdBeginConditionalRenderingEXT(cmdBuffer, &conditionalRenderingBegin);
        drawMeshTasks(vkd, cmdBuffer);
        vkd.cmdEndConditionalRenderingEXT(cmdBuffer);
        endCommandBuffer(vkd, cmdBuffer);

        vkd.cmdExecuteCommands(primary, 1u, &cmdBuffer);
        endRenderPass(vkd, primary);
    }
    else if (m_params.cmdBufferType == CmdBufferType::SECONDARY_WITH_INHERITANCE)
    {
        // Inherit everything in the secondary command buffer.
        vkd.beginCommandBuffer(secondary, &secondaryBeginInfo);
        vkd.cmdBindPipeline(secondary, bindPoint, pipeline.get());
        drawMeshTasks(vkd, secondary);
        endCommandBuffer(vkd, secondary);

        vkd.cmdBeginConditionalRenderingEXT(primary, &conditionalRenderingBegin);
        beginRenderPass(vkd, primary, renderPass.get(), framebuffer.get(), scissors.at(0u), clearColor,
                        VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
        vkd.cmdExecuteCommands(primary, 1u, &secondary);
        endRenderPass(vkd, primary);
        vkd.cmdEndConditionalRenderingEXT(primary);
    }
    else
        DE_ASSERT(false);

    // Transfer color attachment to the verification buffer.
    const auto postTransferBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
    const auto copyRegion          = makeBufferImageCopy(colorExtent, colorSRL);
    const auto preTranferBarrier   = makeImageMemoryBarrier(
        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorAtt.get(), colorSRR);

    cmdPipelineImageMemoryBarrier(vkd, primary, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                                  VK_PIPELINE_STAGE_TRANSFER_BIT, &preTranferBarrier);
    vkd.cmdCopyImageToBuffer(primary, colorAtt.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, verifBuffer.get(), 1u,
                             &copyRegion);
    cmdPipelineMemoryBarrier(vkd, primary, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
                             &postTransferBarrier);

    endCommandBuffer(vkd, primary);
    submitCommandsAndWait(vkd, device, queue, primary);

    invalidateAlloc(vkd, device, verifBufferAlloc);

    const tcu::ConstPixelBufferAccess resultAccess(tcuFormat, iExtent3D, verifBufferData);
    const bool expectDraw    = ((m_params.condValue != 0u) != m_params.inverted);
    const auto expectedColor = (expectDraw ? drawColor : clearColor);
    const tcu::Vec4 threshold(0.0f, 0.0f, 0.0f, 0.0f);

    auto &log = m_context.getTestContext().getLog();
    if (!tcu::floatThresholdCompare(log, "Result", "", expectedColor, resultAccess, threshold,
                                    tcu::COMPARE_LOG_ON_ERROR))
        TCU_FAIL("Check log for details");

    return tcu::TestStatus::pass("Pass");
}

} // namespace

tcu::TestCaseGroup *createMeshShaderConditionalRenderingTestsEXT(tcu::TestContext &testCtx)
{
    GroupPtr mainGroup(new tcu::TestCaseGroup(testCtx, "conditional_rendering"));

    const struct
    {
        DrawType drawType;
        const char *name;
    } drawTypeCases[] = {
        {DrawType::DRAW, "draw"},
        {DrawType::DRAW_INDIRECT, "draw_indirect"},
        {DrawType::DRAW_INDIRECT_WITH_COUNT, "draw_indirect_count"},
    };

    const struct
    {
        CmdBufferType cmdBufferType;
        const char *name;
    } cmdBufferTypeCases[] = {
        {CmdBufferType::PRIMARY, "primary_cmd_buffer"},
        {CmdBufferType::SECONDARY, "secondary_cmd_buffer"},
        {CmdBufferType::SECONDARY_WITH_INHERITANCE, "secondary_cmd_buffer_inheritance"},
    };

    const struct
    {
        bool bindWithOffset;
        const char *name;
    } bindWithOffsetCases[] = {
        {false, "bind_without_offset"},
        {true, "bind_with_offset"},
    };

    const struct
    {
        bool condWithOffset;
        const char *name;
    } condWithOffsetCases[] = {
        {false, "cond_without_offset"},
        {true, "cond_with_offset"},
    };

    const struct
    {
        bool inverted;
        const char *name;
    } inversionCases[] = {
        {false, "normal_cond"},
        {true, "inverted_cond"},
    };

    const struct
    {
        bool useTask;
        const char *name;
    } useTaskCases[] = {
        {false, "mesh_only"},
        {true, "mesh_and_task"},
    };

    const auto condValues = getCondValues();

    for (const auto &drawTypeCase : drawTypeCases)
    {
        GroupPtr drawTypeGroup(new tcu::TestCaseGroup(testCtx, drawTypeCase.name));

        for (const auto &cmdBufferTypeCase : cmdBufferTypeCases)
        {
            GroupPtr cmdBufferTypeGroup(new tcu::TestCaseGroup(testCtx, cmdBufferTypeCase.name));

            for (const auto &bindWithOffsetCase : bindWithOffsetCases)
            {
                GroupPtr bindWithOffsetGroup(new tcu::TestCaseGroup(testCtx, bindWithOffsetCase.name));

                for (const auto &condWithOffsetCase : condWithOffsetCases)
                {
                    GroupPtr condWithOffsetGroup(new tcu::TestCaseGroup(testCtx, condWithOffsetCase.name));

                    for (const auto &inversionCase : inversionCases)
                    {
                        GroupPtr inversionGroup(new tcu::TestCaseGroup(testCtx, inversionCase.name));

                        for (const auto &useTaskCase : useTaskCases)
                        {
                            GroupPtr useTaskGroup(new tcu::TestCaseGroup(testCtx, useTaskCase.name));

                            for (const auto &condValue : condValues)
                            {
                                const auto testName     = "value_" + paddedHex(condValue);
                                const TestParams params = {
                                    drawTypeCase.drawType,             // DrawType drawType;
                                    cmdBufferTypeCase.cmdBufferType,   // CmdBufferType cmdBufferType;
                                    bindWithOffsetCase.bindWithOffset, // bool bindWithOffset;
                                    condWithOffsetCase.condWithOffset, // bool condWithOffset;
                                    condValue,                         // uint32_t condValue;
                                    inversionCase.inverted,            // bool inverted;
                                    useTaskCase.useTask,               // bool useTask;
                                };
                                useTaskGroup->addChild(new ConditionalRenderingCase(testCtx, testName, params));
                            }

                            inversionGroup->addChild(useTaskGroup.release());
                        }

                        condWithOffsetGroup->addChild(inversionGroup.release());
                    }

                    bindWithOffsetGroup->addChild(condWithOffsetGroup.release());
                }

                cmdBufferTypeGroup->addChild(bindWithOffsetGroup.release());
            }

            drawTypeGroup->addChild(cmdBufferTypeGroup.release());
        }

        mainGroup->addChild(drawTypeGroup.release());
    }

    return mainGroup.release();
}

} // namespace MeshShader
} // namespace vkt