external/vulkancts/modules/vulkan/draw/vktDrawShaderDrawParametersTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief VK_KHR_shader_draw_parameters tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktDrawShaderDrawParametersTests.hpp"
  25
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktDrawTestCaseUtil.hpp"
  28 #include "vktDrawBaseClass.hpp"
  29
  30 #include "vkQueryUtil.hpp"
  31
  32 #include "tcuTestLog.hpp"
  33 #include "tcuImageCompare.hpp"
  34 #include "tcuTextureUtil.hpp"
  35
  36 namespace vkt
  37 {
  38 namespace Draw
  39 {
  40 namespace
  41 {
  42
  43 enum TestFlagBits
  44 {
  45         TEST_FLAG_INSTANCED                     = 1u << 0,
  46         TEST_FLAG_INDEXED                       = 1u << 1,
  47         TEST_FLAG_INDIRECT                      = 1u << 2,
  48         TEST_FLAG_MULTIDRAW                     = 1u << 3,      //!< multiDrawIndirect
  49         TEST_FLAG_FIRST_INSTANCE        = 1u << 4,      //!< drawIndirectFirstInstance
  50 };
  51 typedef deUint32 TestFlags;
  52
  53 struct FlagsTestSpec : public TestSpecBase
  54 {
  55         TestFlags       flags;
  56 };
  57
  58 inline FlagsTestSpec addFlags (FlagsTestSpec spec, const TestFlags flags)
  59 {
  60         spec.flags |= flags;
  61         return spec;
  62 }
  63
  64 enum Constants
  65 {
  66         // \note Data layout in buffers (junk data and good data is intertwined).
  67         //       Values are largely arbitrary, but we try to avoid "nice" numbers to make sure the test doesn't pass by accident.
  68         NUM_VERTICES                    = 4,    //!< number of consecutive good vertices
  69         NDX_FIRST_VERTEX                = 2,    //!< index of first good vertex data
  70         NDX_SECOND_VERTEX               = 9,    //!< index of second good vertex data
  71         NDX_FIRST_INDEX                 = 11,   //!< index of a first good index (in index data)
  72         NDX_SECOND_INDEX                = 17,   //!< index of a second good index
  73         OFFSET_FIRST_INDEX              = 1,    //!< offset added to the first index
  74         OFFSET_SECOND_INDEX             = 4,    //!< offset added to the second index
  75         MAX_INSTANCE_COUNT              = 3,    //!< max number of draw instances
  76         MAX_INDIRECT_DRAW_COUNT = 3,    //!< max drawCount of indirect calls
  77 };
  78
  79 class DrawTest : public DrawTestsBaseClass
  80 {
  81 public:
  82         typedef FlagsTestSpec   TestSpec;
  83                                                         DrawTest                                (Context &context, TestSpec testSpec);
  84         tcu::TestStatus                 iterate                                 (void);
  85
  86 private:
  87         template<typename T, std::size_t N>
  88         void                                    setIndirectCommand              (const T (&pCmdData)[N]);
  89
  90         void                                    drawReferenceImage              (const tcu::PixelBufferAccess& refImage) const;
  91
  92         bool                                    isInstanced                             (void) const { return (m_flags & TEST_FLAG_INSTANCED)           != 0; }
  93         bool                                    isIndexed                               (void) const { return (m_flags & TEST_FLAG_INDEXED)                     != 0; }
  94         bool                                    isIndirect                              (void) const { return (m_flags & TEST_FLAG_INDIRECT)            != 0; }
  95         bool                                    isMultiDraw                             (void) const { return (m_flags & TEST_FLAG_MULTIDRAW)           != 0; }
  96         bool                                    isFirstInstance                 (void) const { return (m_flags & TEST_FLAG_FIRST_INSTANCE)      != 0; }
  97
  98         const TestFlags                 m_flags;
  99         de::SharedPtr<Buffer>   m_indexBuffer;
 100         de::SharedPtr<Buffer>   m_indirectBuffer;
 101 };
 102
 103 DrawTest::DrawTest (Context &context, TestSpec testSpec)
 104         : DrawTestsBaseClass(context, testSpec.shaders[glu::SHADERTYPE_VERTEX], testSpec.shaders[glu::SHADERTYPE_FRAGMENT], testSpec.topology)
 105         , m_flags                       (testSpec.flags)
 106 {
 107         DE_ASSERT(m_topology == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP);
 108         DE_ASSERT(!isMultiDraw()     || isIndirect());
 109         DE_ASSERT(!isFirstInstance() || (isIndirect() && isInstanced()));
 110
 111         // Requirements
 112         {
 113                 if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), std::string("VK_KHR_shader_draw_parameters")))
 114                         TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_shader_draw_parameters");
 115
 116                 if (isMultiDraw() && !m_context.getDeviceFeatures().multiDrawIndirect)
 117                         TCU_THROW(NotSupportedError, "Missing feature: multiDrawIndirect");
 118
 119                 if (isFirstInstance() && !m_context.getDeviceFeatures().drawIndirectFirstInstance)
 120                         TCU_THROW(NotSupportedError, "Missing feature: drawIndirectFirstInstance");
 121         }
 122
 123         // Vertex data
 124         {
 125                 int refIndex = NDX_FIRST_VERTEX - OFFSET_FIRST_INDEX;
 126
 127                 m_data.push_back(VertexElementData(tcu::Vec4( 1.0f, -1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 128                 m_data.push_back(VertexElementData(tcu::Vec4(-1.0f,  1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 129
 130                 if (!isIndexed())
 131                         refIndex = 0;
 132
 133                 m_data.push_back(VertexElementData(tcu::Vec4(-0.3f,     -0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 134                 m_data.push_back(VertexElementData(tcu::Vec4(-0.3f,      0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 135                 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f,     -0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 136                 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f,      0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 137
 138                 m_data.push_back(VertexElementData(tcu::Vec4(-1.0f,  1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 139                 m_data.push_back(VertexElementData(tcu::Vec4( 1.0f, -1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 140                 m_data.push_back(VertexElementData(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 141
 142                 if (!isIndexed())
 143                         refIndex = 0;
 144
 145                 m_data.push_back(VertexElementData(tcu::Vec4(-0.3f,     -0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 146                 m_data.push_back(VertexElementData(tcu::Vec4(-0.3f,      0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 147                 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f,     -0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 148                 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f,      0.3f, 1.0f, 1.0f), tcu::Vec4(1.0f), refIndex++));
 149
 150                 m_data.push_back(VertexElementData(tcu::Vec4(-1.0f,  1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 151                 m_data.push_back(VertexElementData(tcu::Vec4( 1.0f, -1.0f, 1.0f, 1.0f), tcu::Vec4(1.0f), -1));
 152
 153                 // Make sure constants are up to date
 154                 DE_ASSERT(m_data.size() == NDX_SECOND_VERTEX + NUM_VERTICES + 2);
 155                 DE_ASSERT(NDX_SECOND_VERTEX - NDX_FIRST_VERTEX - NUM_VERTICES == 3);
 156         }
 157
 158         if (isIndirect())
 159         {
 160                 const std::size_t       indirectBufferSize      = MAX_INDIRECT_DRAW_COUNT * 32; // space for COUNT commands plus some gratuitous padding
 161                                                         m_indirectBuffer        = Buffer::createAndAlloc(m_vk, m_context.getDevice(), BufferCreateInfo(indirectBufferSize, vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT),
 162                                                                                                   m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
 163
 164                 deMemset(m_indirectBuffer->getBoundMemory().getHostPtr(), 0, indirectBufferSize);
 165                 vk::flushMappedMemoryRange(m_vk, m_context.getDevice(), m_indirectBuffer->getBoundMemory().getMemory(), m_indirectBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 166         }
 167
 168         if (isIndexed())
 169         {
 170                 DE_ASSERT(NDX_FIRST_INDEX + NUM_VERTICES <= NDX_SECOND_INDEX);
 171                 const std::size_t       indexBufferSize = sizeof(deUint32) * (NDX_SECOND_INDEX + NUM_VERTICES);
 172                                                         m_indexBuffer   = Buffer::createAndAlloc(m_vk, m_context.getDevice(), BufferCreateInfo(indexBufferSize, vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT),
 173                                                                                                                                          m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
 174                 deUint32*                       indices                 = static_cast<deUint32*>(m_indexBuffer->getBoundMemory().getHostPtr());
 175
 176                 deMemset(indices, 0, indexBufferSize);
 177
 178                 for (int i = 0; i < NUM_VERTICES; i++)
 179                 {
 180                         indices[NDX_FIRST_INDEX  + i] = static_cast<deUint32>(NDX_FIRST_VERTEX  + i) - OFFSET_FIRST_INDEX;
 181                         indices[NDX_SECOND_INDEX + i] = static_cast<deUint32>(NDX_SECOND_VERTEX + i) - OFFSET_SECOND_INDEX;
 182                 }
 183
 184                 vk::flushMappedMemoryRange(m_vk, m_context.getDevice(), m_indexBuffer->getBoundMemory().getMemory(), m_indexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 185         }
 186
 187         initialize();
 188 }
 189
 190 template<typename T, std::size_t N>
 191 void DrawTest::setIndirectCommand (const T (&pCmdData)[N])
 192 {
 193         DE_ASSERT(N != 0 && N <= MAX_INDIRECT_DRAW_COUNT);
 194
 195         const std::size_t dataSize = N * sizeof(T);
 196
 197         deMemcpy(m_indirectBuffer->getBoundMemory().getHostPtr(), pCmdData, dataSize);
 198         vk::flushMappedMemoryRange(m_vk, m_context.getDevice(), m_indirectBuffer->getBoundMemory().getMemory(), m_indirectBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 199 }
 200
 201 //! This function must be kept in sync with the shader.
 202 void DrawTest::drawReferenceImage (const tcu::PixelBufferAccess& refImage) const
 203 {
 204         using tcu::Vec2;
 205         using tcu::Vec4;
 206         using tcu::IVec4;
 207
 208         const Vec2      perInstanceOffset[]     = { Vec2(0.0f, 0.0f), Vec2(-0.3f,  0.0f), Vec2(0.0f, 0.3f) };
 209         const Vec2      perDrawOffset[]         = { Vec2(0.0f, 0.0f), Vec2(-0.3f, -0.3f), Vec2(0.3f, 0.3f) };
 210         const Vec4      allColors[]                     = { Vec4(1.0f), Vec4(0.0f, 0.0f, 1.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f) };
 211         const int       numInstances            = isInstanced() ? MAX_INSTANCE_COUNT            : 1;
 212         const int       numIndirectDraws        = isMultiDraw() ? MAX_INDIRECT_DRAW_COUNT       : 1;
 213         const int       rectWidth                       = static_cast<int>(WIDTH  * 0.6f / 2.0f);
 214         const int       rectHeight                      = static_cast<int>(HEIGHT * 0.6f / 2.0f);
 215
 216         DE_ASSERT(DE_LENGTH_OF_ARRAY(perInstanceOffset) >= numInstances);
 217         DE_ASSERT(DE_LENGTH_OF_ARRAY(allColors) >= numInstances && DE_LENGTH_OF_ARRAY(allColors) >= numIndirectDraws);
 218         DE_ASSERT(DE_LENGTH_OF_ARRAY(perDrawOffset) >= numIndirectDraws);
 219
 220         tcu::clear(refImage, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 221
 222         for (int drawNdx     = 0; drawNdx     < numIndirectDraws; ++drawNdx)
 223         for (int instanceNdx = 0; instanceNdx < numInstances;     ++instanceNdx)
 224         {
 225                 const Vec2      offset  = perInstanceOffset[instanceNdx] + perDrawOffset[drawNdx];
 226                 const Vec4&     color   = allColors[isMultiDraw() ? drawNdx : instanceNdx];
 227                 int                     x               = static_cast<int>(WIDTH  * (1.0f - 0.3f + offset.x()) / 2.0f);
 228                 int                     y               = static_cast<int>(HEIGHT * (1.0f - 0.3f + offset.y()) / 2.0f);
 229
 230                 tcu::clear(tcu::getSubregion(refImage, x, y, rectWidth, rectHeight), color);
 231         }
 232 }
 233
 234 tcu::TestStatus DrawTest::iterate (void)
 235 {
 236         // Draw
 237         {
 238                 beginRenderPass();
 239
 240                 const vk::VkDeviceSize  vertexBufferOffset      = 0;
 241                 const vk::VkBuffer              vertexBuffer            = m_vertexBuffer->object();
 242
 243                 m_vk.cmdBindVertexBuffers       (*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
 244                 m_vk.cmdBindPipeline            (*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 245
 246                 if (isIndexed())
 247                         m_vk.cmdBindIndexBuffer(*m_cmdBuffer, m_indexBuffer->object(), 0ull, vk::VK_INDEX_TYPE_UINT32);
 248
 249                 const deUint32                  numInstances            = isInstanced() ? MAX_INSTANCE_COUNT : 1;
 250
 251                 if (isIndirect())
 252                 {
 253                         if (isIndexed())
 254                         {
 255                                 const vk::VkDrawIndexedIndirectCommand commands[] =
 256                                 {
 257                                         // indexCount, instanceCount, firstIndex, vertexOffset, firstInstance
 258                                         { NUM_VERTICES, numInstances,   NDX_FIRST_INDEX,        OFFSET_FIRST_INDEX,             (isFirstInstance() ? 2u : 0u) },
 259                                         { NUM_VERTICES, numInstances,   NDX_SECOND_INDEX,       OFFSET_SECOND_INDEX,    (isFirstInstance() ? 1u : 0u) },
 260                                         { NUM_VERTICES, numInstances,   NDX_FIRST_INDEX,        OFFSET_FIRST_INDEX,             (isFirstInstance() ? 3u : 0u) },
 261                                 };
 262                                 setIndirectCommand(commands);
 263                         }
 264                         else
 265                         {
 266                                 const vk::VkDrawIndirectCommand commands[] =
 267                                 {
 268                                         // vertexCount, instanceCount, firstVertex, firstInstance
 269                                         { NUM_VERTICES, numInstances,   NDX_FIRST_VERTEX,       (isFirstInstance() ? 2u : 0u) },
 270                                         { NUM_VERTICES, numInstances,   NDX_SECOND_VERTEX,      (isFirstInstance() ? 1u : 0u) },
 271                                         { NUM_VERTICES, numInstances,   NDX_FIRST_VERTEX,       (isFirstInstance() ? 3u : 0u) },
 272                                 };
 273                                 setIndirectCommand(commands);
 274                         }
 275                 }
 276
 277                 if (isIndirect())
 278                 {
 279                         const deUint32 numIndirectDraws = isMultiDraw() ? MAX_INDIRECT_DRAW_COUNT : 1;
 280
 281                         if (isIndexed())
 282                                 m_vk.cmdDrawIndexedIndirect(*m_cmdBuffer, m_indirectBuffer->object(), 0ull, numIndirectDraws, sizeof(vk::VkDrawIndexedIndirectCommand));
 283                         else
 284                                 m_vk.cmdDrawIndirect(*m_cmdBuffer, m_indirectBuffer->object(), 0ull, numIndirectDraws, sizeof(vk::VkDrawIndirectCommand));
 285                 }
 286                 else
 287                 {
 288                         const deUint32 firstInstance = 2;
 289
 290                         if (isIndexed())
 291                                 m_vk.cmdDrawIndexed(*m_cmdBuffer, NUM_VERTICES, numInstances, NDX_FIRST_INDEX, OFFSET_FIRST_INDEX, firstInstance);
 292                         else
 293                                 m_vk.cmdDraw(*m_cmdBuffer, NUM_VERTICES, numInstances, NDX_FIRST_VERTEX, firstInstance);
 294                 }
 295
 296                 m_vk.cmdEndRenderPass(*m_cmdBuffer);
 297                 m_vk.endCommandBuffer(*m_cmdBuffer);
 298         }
 299
 300         // Submit
 301         {
 302                 const vk::VkQueue               queue           = m_context.getUniversalQueue();
 303                 const vk::VkSubmitInfo  submitInfo      =
 304                 {
 305                         vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,                      // VkStructureType                      sType;
 306                         DE_NULL,                                                                        // const void*                          pNext;
 307                         0,                                                                                      // deUint32                                     waitSemaphoreCount;
 308                         DE_NULL,                                                                        // const VkSemaphore*           pWaitSemaphores;
 309                         (const vk::VkPipelineStageFlags*)DE_NULL,
 310                         1,                                                                                      // deUint32                                     commandBufferCount;
 311                         &m_cmdBuffer.get(),                                                     // const VkCommandBuffer*       pCommandBuffers;
 312                         0,                                                                                      // deUint32                                     signalSemaphoreCount;
 313                         DE_NULL                                                                         // const VkSemaphore*           pSignalSemaphores;
 314                 };
 315                 VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
 316                 VK_CHECK(m_vk.queueWaitIdle(queue));
 317         }
 318
 319         // Validate
 320         {
 321                 tcu::TextureLevel referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), static_cast<int>(0.5f + WIDTH), static_cast<int>(0.5f + HEIGHT));
 322
 323                 drawReferenceImage(referenceFrame.getAccess());
 324
 325                 const vk::VkOffset3D                            zeroOffset              = { 0, 0, 0 };
 326                 const tcu::ConstPixelBufferAccess       renderedFrame   = m_colorTargetImage->readSurface(m_context.getUniversalQueue(), m_context.getDefaultAllocator(),
 327                                                                                                                           vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
 328
 329                 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "Result", "Image comparison result", referenceFrame.getAccess(), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT))
 330                         return tcu::TestStatus::fail("Rendered image is incorrect");
 331                 else
 332                         return tcu::TestStatus::pass("OK");
 333         }
 334 }
 335
 336 void addDrawCase (tcu::TestCaseGroup* group, const DrawTest::TestSpec testSpec, const TestFlags flags)
 337 {
 338         std::ostringstream name;
 339         name << "draw";
 340
 341         if (flags & TEST_FLAG_INDEXED)                  name << "_indexed";
 342         if (flags & TEST_FLAG_INDIRECT)                 name << "_indirect";
 343         if (flags & TEST_FLAG_INSTANCED)                name << "_instanced";
 344         if (flags & TEST_FLAG_FIRST_INSTANCE)   name << "_first_instance";
 345
 346         group->addChild(new InstanceFactory<DrawTest>(group->getTestContext(), name.str(), "", addFlags(testSpec, flags)));
 347 }
 348
 349 }       // anonymous
 350
 351 ShaderDrawParametersTests::ShaderDrawParametersTests (tcu::TestContext &testCtx)
 352         : TestCaseGroup (testCtx, "shader_draw_parameters", "VK_KHR_shader_draw_parameters")
 353 {
 354 }
 355
 356 void ShaderDrawParametersTests::init (void)
 357 {
 358         {
 359                 DrawTest::TestSpec testSpec;
 360                 testSpec.shaders[glu::SHADERTYPE_VERTEX]        = "vulkan/draw/VertexFetchShaderDrawParameters.vert";
 361                 testSpec.shaders[glu::SHADERTYPE_FRAGMENT]      = "vulkan/draw/VertexFetch.frag";
 362                 testSpec.topology                                                       = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 363                 testSpec.flags                                                          = 0;
 364
 365                 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(getTestContext(), "base_vertex", ""));
 366                 addDrawCase(group.get(), testSpec, 0);
 367                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED);
 368                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDIRECT);
 369                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED | TEST_FLAG_INDIRECT);
 370                 addChild(group.release());
 371         }
 372         {
 373                 DrawTest::TestSpec testSpec;
 374                 testSpec.shaders[glu::SHADERTYPE_VERTEX]        = "vulkan/draw/VertexFetchShaderDrawParameters.vert";
 375                 testSpec.shaders[glu::SHADERTYPE_FRAGMENT]      = "vulkan/draw/VertexFetch.frag";
 376                 testSpec.topology                                                       = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 377                 testSpec.flags                                                          = TEST_FLAG_INSTANCED;
 378
 379                 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(getTestContext(), "base_instance", ""));
 380                 addDrawCase(group.get(), testSpec, 0);
 381                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED);
 382                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDIRECT);
 383                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDIRECT | TEST_FLAG_FIRST_INSTANCE);
 384                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED  | TEST_FLAG_INDIRECT);
 385                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED  | TEST_FLAG_INDIRECT | TEST_FLAG_FIRST_INSTANCE);
 386                 addChild(group.release());
 387         }
 388         {
 389                 DrawTest::TestSpec testSpec;
 390                 testSpec.shaders[glu::SHADERTYPE_VERTEX]        = "vulkan/draw/VertexFetchShaderDrawParametersDrawIndex.vert";
 391                 testSpec.shaders[glu::SHADERTYPE_FRAGMENT]      = "vulkan/draw/VertexFetch.frag";
 392                 testSpec.topology                                                       = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 393                 testSpec.flags                                                          = TEST_FLAG_INDIRECT | TEST_FLAG_MULTIDRAW;
 394
 395                 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(getTestContext(), "draw_index", ""));
 396                 addDrawCase(group.get(), testSpec, 0);
 397                 addDrawCase(group.get(), testSpec, TEST_FLAG_INSTANCED);
 398                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED);
 399                 addDrawCase(group.get(), testSpec, TEST_FLAG_INDEXED | TEST_FLAG_INSTANCED);
 400                 addChild(group.release());
 401         }
 402 }
 403
 404 }       // DrawTests
 405 }       // vkt