1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2021 The Khronos Group Inc.
6 * Copyright (c) 2021 Valve Corporation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Mesh Shader API Tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktMeshShaderApiTests.hpp"
26 #include "vktMeshShaderUtil.hpp"
27 #include "vktTestCase.hpp"
28
29 #include "vkTypeUtil.hpp"
30 #include "vkImageWithMemory.hpp"
31 #include "vkBufferWithMemory.hpp"
32 #include "vkObjUtil.hpp"
33 #include "vkBuilderUtil.hpp"
34 #include "vkCmdUtil.hpp"
35 #include "vkImageUtil.hpp"
36
37 #include "tcuMaybe.hpp"
38 #include "tcuTestLog.hpp"
39 #include "tcuImageCompare.hpp"
40
41 #include "deRandom.hpp"
42
43 #include <iostream>
44 #include <sstream>
45 #include <vector>
46 #include <algorithm>
47 #include <iterator>
48 #include <limits>
49
50 namespace vkt
51 {
52 namespace MeshShader
53 {
54
55 namespace
56 {
57
58 using namespace vk;
59
60 using GroupPtr = de::MovePtr<tcu::TestCaseGroup>;
61 using ImageWithMemoryPtr = de::MovePtr<ImageWithMemory>;
62 using BufferWithMemoryPtr = de::MovePtr<BufferWithMemory>;
63
64 enum class DrawType
65 {
66 DRAW = 0,
67 DRAW_INDIRECT,
68 DRAW_INDIRECT_COUNT,
69 };
70
operator <<(std::ostream & stream,DrawType drawType)71 std::ostream& operator<< (std::ostream& stream, DrawType drawType)
72 {
73 switch (drawType)
74 {
75 case DrawType::DRAW: stream << "draw"; break;
76 case DrawType::DRAW_INDIRECT: stream << "draw_indirect"; break;
77 case DrawType::DRAW_INDIRECT_COUNT: stream << "draw_indirect_count"; break;
78 default: DE_ASSERT(false); break;
79 }
80 return stream;
81 }
82
83
84 // This helps test the maxDrawCount rule for the DRAW_INDIRECT_COUNT case.
85 enum class IndirectCountLimitType
86 {
87 BUFFER_VALUE = 0, // The actual count will be given by the count buffer.
88 MAX_COUNT, // The actual count will be given by the maxDrawCount argument passed to the draw command.
89 };
90
91 struct IndirectArgs
92 {
93 uint32_t offset;
94 uint32_t stride;
95 };
96
97 struct TestParams
98 {
99 DrawType drawType;
100 uint32_t seed;
101 uint32_t drawCount; // Equivalent to taskCount or drawCount.
102 uint32_t firstTask; // Equivalent to firstTask in every call.
103 tcu::Maybe<IndirectArgs> indirectArgs; // Only used for DRAW_INDIRECT*.
104 tcu::Maybe<IndirectCountLimitType> indirectCountLimit; // Only used for DRAW_INDIRECT_COUNT.
105 tcu::Maybe<uint32_t> indirectCountOffset; // Only used for DRAW_INDIRECT_COUNT.
106 bool useTask;
107 };
108
109 // The framebuffer will have a number of rows and 32 columns. Each mesh shader workgroup will generate geometry to fill a single
110 // framebuffer row, using a triangle list with 32 triangles of different colors, each covering a framebuffer pixel.
111 //
112 // Note: the total framebuffer rows is called "full" below (e.g. 64). When using a task shader to generate work, each workgroup will
113 // generate a single mesh workgroup using a push constant instead of a compile-time constant.
114 //
115 // When using DRAW, the task count will tell us how many rows of pixels will be filled in the framebuffer.
116 //
117 // When using indirect draws, the full framebuffer will always be drawn into by using multiple draw command structures, except in
118 // the case of drawCount==0. Each draw will spawn the needed number of tasks to fill the whole framebuffer. In addition, in order to
119 // make all argument structures different, the number of tasks in each draw count will be slightly different and assigned
120 // pseudorandomly.
121 //
122 // DRAW: taskCount=0, taskCount=1, taskCount=2, taskCount=half, taskCount=full
123 //
124 // DRAW_INDIRECT: drawCount=0, drawCount=1, drawCount=2, drawCount=half, drawCount=full.
125 // * With offset 0 and pseudorandom (multiples of 4).
126 // * With stride adding a padding of 0 and pseudorandom (multiples of 4).
127 //
128 // DRAW_INDIRECT_COUNT: same as indirect in two variants:
129 // 1. Passing the count in a buffer with a large maximum.
130 // 2. Passing a large value in the buffer and limiting it with the maximum.
131
132 class MeshApiCase : public vkt::TestCase
133 {
134 public:
MeshApiCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const TestParams & params)135 MeshApiCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParams& params)
136 : vkt::TestCase (testCtx, name, description)
137 , m_params (params)
138 {}
~MeshApiCase(void)139 virtual ~MeshApiCase (void) {}
140
141 void initPrograms (vk::SourceCollections& programCollection) const override;
142 void checkSupport (Context& context) const override;
143 TestInstance* createInstance (Context& context) const override;
144
145 protected:
146 TestParams m_params;
147 };
148
149 class MeshApiInstance : public vkt::TestInstance
150 {
151 public:
MeshApiInstance(Context & context,const TestParams & params)152 MeshApiInstance (Context& context, const TestParams& params)
153 : vkt::TestInstance (context)
154 , m_params (params)
155 {}
~MeshApiInstance(void)156 virtual ~MeshApiInstance (void) {}
157
158 tcu::TestStatus iterate (void) override;
159
160 protected:
161 TestParams m_params;
162 };
163
createInstance(Context & context) const164 TestInstance* MeshApiCase::createInstance (Context& context) const
165 {
166 return new MeshApiInstance(context, m_params);
167 }
168
169 struct PushConstantData
170 {
171 uint32_t width;
172 uint32_t height;
173 uint32_t firstTaskMesh;
174 uint32_t one;
175 uint32_t firstTaskTask;
176
getRangesvkt::MeshShader::__anon082346570111::PushConstantData177 std::vector<VkPushConstantRange> getRanges (bool includeTask) const
178 {
179 constexpr uint32_t offsetMesh = 0u;
180 constexpr uint32_t offsetTask = static_cast<uint32_t>(offsetof(PushConstantData, one));
181 constexpr uint32_t sizeMesh = offsetTask;
182 constexpr uint32_t sizeTask = static_cast<uint32_t>(sizeof(PushConstantData)) - offsetTask;
183
184 const VkPushConstantRange meshRange =
185 {
186 VK_SHADER_STAGE_MESH_BIT_NV, // VkShaderStageFlags stageFlags;
187 offsetMesh, // uint32_t offset;
188 sizeMesh, // uint32_t size;
189 };
190 const VkPushConstantRange taskRange =
191 {
192 VK_SHADER_STAGE_TASK_BIT_NV, // VkShaderStageFlags stageFlags;
193 offsetTask, // uint32_t offset;
194 sizeTask, // uint32_t size;
195 };
196
197 std::vector<VkPushConstantRange> ranges (1u, meshRange);
198 if (includeTask)
199 ranges.push_back(taskRange);
200 return ranges;
201 }
202 };
203
initPrograms(vk::SourceCollections & programCollection) const204 void MeshApiCase::initPrograms (vk::SourceCollections& programCollection) const
205 {
206 const std::string taskDataDecl =
207 "taskNV TaskData {\n"
208 " uint blockNumber;\n"
209 " uint blockRow;\n"
210 "} td;\n"
211 ;
212
213 // Task shader if needed.
214 if (m_params.useTask)
215 {
216 std::ostringstream task;
217 task
218 << "#version 460\n"
219 << "#extension GL_NV_mesh_shader : enable\n"
220 << "\n"
221 << "layout (local_size_x=1) in;\n"
222 << "\n"
223 << "layout (push_constant, std430) uniform TaskPushConstantBlock {\n"
224 << " layout (offset=12) uint one;\n"
225 << " layout (offset=16) uint firstTask;\n"
226 << "} pc;\n"
227 << "\n"
228 << "out " << taskDataDecl
229 << "\n"
230 << "void main ()\n"
231 << "{\n"
232 << " gl_TaskCountNV = pc.one;\n"
233 << " td.blockNumber = uint(gl_DrawID);\n"
234 << " td.blockRow = gl_WorkGroupID.x - pc.firstTask;\n"
235 << "}\n"
236 ;
237 programCollection.glslSources.add("task") << glu::TaskSource(task.str());
238 }
239
240 // Mesh shader.
241 {
242 std::ostringstream mesh;
243 mesh
244 << "#version 460\n"
245 << "#extension GL_NV_mesh_shader : enable\n"
246 << "\n"
247 << "layout (local_size_x=32) in;\n"
248 << "layout (triangles) out;\n"
249 << "layout (max_vertices=96, max_primitives=32) out;\n"
250 << "\n"
251 << "layout (push_constant, std430) uniform MeshPushConstantBlock {\n"
252 << " uint width;\n"
253 << " uint height;\n"
254 << " uint firstTask;\n"
255 << "} pc;\n"
256 << "\n"
257 << "layout (location=0) perprimitiveNV out vec4 primitiveColor[];\n"
258 << "\n"
259 << (m_params.useTask ? ("in " + taskDataDecl): "")
260 << "\n"
261 << "layout (set=0, binding=0, std430) readonly buffer BlockSizes {\n"
262 << " uint blockSize[];\n"
263 << "} bsz;\n"
264 << "\n"
265 << "uint startOfBlock (uint blockNumber)\n"
266 << "{\n"
267 << " uint start = 0;\n"
268 << " for (uint i = 0; i < blockNumber; i++)\n"
269 << " start += bsz.blockSize[i];\n"
270 << " return start;\n"
271 << "}\n"
272 << "\n"
273 << "void main ()\n"
274 << "{\n"
275 << " const uint blockNumber = " << (m_params.useTask ? "td.blockNumber" : "uint(gl_DrawID)") << ";\n"
276 << " const uint blockRow = " << (m_params.useTask ? "td.blockRow" : "(gl_WorkGroupID.x - pc.firstTask)") << ";\n"
277 << "\n"
278 << " // Each workgroup will fill one row, and each invocation will generate a\n"
279 << " // triangle around the pixel center in each column.\n"
280 << " const uint row = startOfBlock(blockNumber) + blockRow;\n"
281 << " const uint col = gl_LocalInvocationID.x;\n"
282 << "\n"
283 << " const float fHeight = float(pc.height);\n"
284 << " const float fWidth = float(pc.width);\n"
285 << "\n"
286 << " // Pixel coordinates, normalized.\n"
287 << " const float rowNorm = (float(row) + 0.5) / fHeight;\n"
288 << " const float colNorm = (float(col) + 0.5) / fWidth;\n"
289 << "\n"
290 << " // Framebuffer coordinates.\n"
291 << " const float coordX = (colNorm * 2.0) - 1.0;\n"
292 << " const float coordY = (rowNorm * 2.0) - 1.0;\n"
293 << "\n"
294 << " const float pixelWidth = 2.0 / fWidth;\n"
295 << " const float pixelHeight = 2.0 / fHeight;\n"
296 << "\n"
297 << " const float offsetX = pixelWidth / 2.0;\n"
298 << " const float offsetY = pixelHeight / 2.0;\n"
299 << "\n"
300 << " const uint baseIndex = col*3;\n"
301 << " const uvec3 indices = uvec3(baseIndex, baseIndex + 1, baseIndex + 2);\n"
302 << "\n"
303 << " gl_PrimitiveCountNV = 32u;\n"
304 << " primitiveColor[col] = vec4(rowNorm, colNorm, 0.0, 1.0);\n"
305 << "\n"
306 << " gl_PrimitiveIndicesNV[indices.x] = indices.x;\n"
307 << " gl_PrimitiveIndicesNV[indices.y] = indices.y;\n"
308 << " gl_PrimitiveIndicesNV[indices.z] = indices.z;\n"
309 << "\n"
310 << " gl_MeshVerticesNV[indices.x].gl_Position = vec4(coordX - offsetX, coordY + offsetY, 0.0, 1.0);\n"
311 << " gl_MeshVerticesNV[indices.y].gl_Position = vec4(coordX + offsetX, coordY + offsetY, 0.0, 1.0);\n"
312 << " gl_MeshVerticesNV[indices.z].gl_Position = vec4(coordX, coordY - offsetY, 0.0, 1.0);\n"
313 << "}\n"
314 ;
315 programCollection.glslSources.add("mesh") << glu::MeshSource(mesh.str());
316 }
317
318 // Frag shader.
319 {
320 std::ostringstream frag;
321 frag
322 << "#version 460\n"
323 << "#extension GL_NV_mesh_shader : enable\n"
324 << "\n"
325 << "layout (location=0) perprimitiveNV in vec4 primitiveColor;\n"
326 << "layout (location=0) out vec4 outColor;\n"
327 << "\n"
328 << "void main ()\n"
329 << "{\n"
330 << " outColor = primitiveColor;\n"
331 << "}\n"
332 ;
333 programCollection.glslSources.add("frag") << glu::FragmentSource(frag.str());
334 }
335 }
336
checkSupport(Context & context) const337 void MeshApiCase::checkSupport (Context& context) const
338 {
339 checkTaskMeshShaderSupportNV(context, m_params.useTask, true);
340
341 // VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718
342 if (m_params.drawType == DrawType::DRAW_INDIRECT && m_params.drawCount > 1u)
343 {
344 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_MULTI_DRAW_INDIRECT);
345 }
346
347 // VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04445
348 if (m_params.drawType == DrawType::DRAW_INDIRECT_COUNT)
349 context.requireDeviceFunctionality("VK_KHR_draw_indirect_count");
350 }
351
352 template <typename T>
makeStridedBuffer(const DeviceInterface & vkd,VkDevice device,Allocator & alloc,const std::vector<T> & elements,uint32_t offset,uint32_t stride,VkBufferUsageFlags usage,uint32_t endPadding)353 BufferWithMemoryPtr makeStridedBuffer(const DeviceInterface& vkd, VkDevice device, Allocator& alloc, const std::vector<T>& elements, uint32_t offset, uint32_t stride, VkBufferUsageFlags usage, uint32_t endPadding)
354 {
355 const auto elementSize = static_cast<uint32_t>(sizeof(T));
356 const auto actualStride = std::max(elementSize, stride);
357 const auto bufferSize = static_cast<size_t>(offset) + static_cast<size_t>(actualStride) * elements.size() + static_cast<size_t>(endPadding);
358 const auto bufferInfo = makeBufferCreateInfo(static_cast<VkDeviceSize>(bufferSize), usage);
359
360 BufferWithMemoryPtr buffer(new BufferWithMemory(vkd, device, alloc, bufferInfo, MemoryRequirement::HostVisible));
361 auto& bufferAlloc = buffer->getAllocation();
362 char* bufferDataPtr = reinterpret_cast<char*>(bufferAlloc.getHostPtr());
363
364 char* itr = bufferDataPtr + offset;
365 for (const auto& elem : elements)
366 {
367 deMemcpy(itr, &elem, sizeof(elem));
368 itr += actualStride;
369 }
370 if (endPadding > 0u)
371 deMemset(itr, 0xFF, endPadding);
372
373 flushAlloc(vkd, device, bufferAlloc);
374
375 return buffer;
376 }
377
getExtent()378 VkExtent3D getExtent ()
379 {
380 return makeExtent3D(32u, 64u, 1u);
381 }
382
iterate(void)383 tcu::TestStatus MeshApiInstance::iterate (void)
384 {
385 const auto& vkd = m_context.getDeviceInterface();
386 const auto device = m_context.getDevice();
387 auto& alloc = m_context.getDefaultAllocator();
388 const auto queueIndex = m_context.getUniversalQueueFamilyIndex();
389 const auto queue = m_context.getUniversalQueue();
390
391 const auto extent = getExtent();
392 const auto iExtent3D = tcu::IVec3(static_cast<int>(extent.width), static_cast<int>(extent.height), static_cast<int>(extent.depth));
393 const auto iExtent2D = tcu::IVec2(iExtent3D.x(), iExtent3D.y());
394 const auto format = VK_FORMAT_R8G8B8A8_UNORM;
395 const auto tcuFormat = mapVkFormat(format);
396 const auto colorUsage = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
397 const auto colorSRR = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
398 const tcu::Vec4 clearColor (0.0f, 0.0f, 0.0f, 1.0f);
399 const float colorThres = 0.005f; // 1/255 < 0.005 < 2/255
400 const tcu::Vec4 threshold (colorThres, colorThres, 0.0f, 0.0f);
401
402 ImageWithMemoryPtr colorBuffer;
403 Move<VkImageView> colorBufferView;
404 {
405 const VkImageCreateInfo colorBufferInfo =
406 {
407 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
408 nullptr, // const void* pNext;
409 0u, // VkImageCreateFlags flags;
410 VK_IMAGE_TYPE_2D, // VkImageType imageType;
411 format, // VkFormat format;
412 extent, // VkExtent3D extent;
413 1u, // uint32_t mipLevels;
414 1u, // uint32_t arrayLayers;
415 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
416 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
417 colorUsage, // VkImageUsageFlags usage;
418 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
419 0u, // uint32_t queueFamilyIndexCount;
420 nullptr, // const uint32_t* pQueueFamilyIndices;
421 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
422 };
423 colorBuffer = ImageWithMemoryPtr(new ImageWithMemory(vkd, device, alloc, colorBufferInfo, MemoryRequirement::Any));
424 colorBufferView = makeImageView(vkd, device, colorBuffer->get(), VK_IMAGE_VIEW_TYPE_2D, format, colorSRR);
425 }
426
427 // Prepare buffer containing the array of block sizes.
428 de::Random rnd (m_params.seed);
429 std::vector<uint32_t> blockSizes;
430
431 const uint32_t vectorSize = std::max(1u, m_params.drawCount);
432 const uint32_t largeDrawCount = vectorSize + 1u; // The indirect buffer needs to have some padding at the end. See below.
433 const uint32_t evenBlockSize = extent.height / vectorSize;
434 uint32_t remainingRows = extent.height;
435
436 blockSizes.reserve(vectorSize);
437 for (uint32_t i = 0; i < vectorSize - 1u; ++i)
438 {
439 const auto blockSize = static_cast<uint32_t>(rnd.getInt(1, evenBlockSize));
440 remainingRows -= blockSize;
441 blockSizes.push_back(blockSize);
442 }
443 blockSizes.push_back(remainingRows);
444
445 const auto blockSizesBufferSize = static_cast<VkDeviceSize>(de::dataSize(blockSizes));
446 BufferWithMemoryPtr blockSizesBuffer = makeStridedBuffer(vkd, device, alloc, blockSizes, 0u, 0u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, 0u);
447
448 // Descriptor set layout, pool and set.
449 DescriptorSetLayoutBuilder layoutBuilder;
450 layoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_MESH_BIT_NV);
451 const auto setLayout = layoutBuilder.build(vkd, device);
452
453 DescriptorPoolBuilder poolBuilder;
454 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
455 const auto descriptorPool = poolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
456
457 const auto descriptorSet = makeDescriptorSet(vkd, device, descriptorPool.get(), setLayout.get());
458
459 // Update descriptor set.
460 {
461 DescriptorSetUpdateBuilder updateBuilder;
462
463 const auto location = DescriptorSetUpdateBuilder::Location::binding(0u);
464 const auto descriptorBufferInfo = makeDescriptorBufferInfo(blockSizesBuffer->get(), 0ull, blockSizesBufferSize);
465
466 updateBuilder.writeSingle(descriptorSet.get(), location, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo);
467 updateBuilder.update(vkd, device);
468 }
469
470 // Pipeline layout.
471 PushConstantData pcData;
472 const auto pcRanges = pcData.getRanges(m_params.useTask);
473 const auto pipelineLayout = makePipelineLayout(vkd, device, 1u, &setLayout.get(), static_cast<uint32_t>(pcRanges.size()), de::dataOrNull(pcRanges));
474
475 // Push constants.
476 pcData.width = extent.width;
477 pcData.height = extent.height;
478 pcData.firstTaskMesh = m_params.firstTask;
479 pcData.one = 1u;
480 pcData.firstTaskTask = m_params.firstTask;
481
482 // Render pass and framebuffer.
483 const auto renderPass = makeRenderPass(vkd, device, format);
484 const auto framebuffer = makeFramebuffer(vkd, device, renderPass.get(), colorBufferView.get(), extent.width, extent.height);
485
486 // Pipeline.
487 Move<VkShaderModule> taskModule;
488 Move<VkShaderModule> meshModule;
489 Move<VkShaderModule> fragModule;
490
491 const auto& binaries = m_context.getBinaryCollection();
492 if (m_params.useTask)
493 taskModule = createShaderModule(vkd, device, binaries.get("task"));
494 meshModule = createShaderModule(vkd, device, binaries.get("mesh"));
495 fragModule = createShaderModule(vkd, device, binaries.get("frag"));
496
497 const std::vector<VkViewport> viewports (1u, makeViewport(extent));
498 const std::vector<VkRect2D> scissors (1u, makeRect2D(extent));
499
500 const auto pipeline = makeGraphicsPipeline(vkd, device, pipelineLayout.get(),
501 taskModule.get(), meshModule.get(), fragModule.get(),
502 renderPass.get(), viewports, scissors);
503
504 // Command pool and buffer.
505 const auto cmdPool = makeCommandPool(vkd, device, queueIndex);
506 const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
507 const auto cmdBuffer = cmdBufferPtr.get();
508
509 // Indirect and count buffers if needed.
510 BufferWithMemoryPtr indirectBuffer;
511 BufferWithMemoryPtr countBuffer;
512
513 if (m_params.drawType != DrawType::DRAW)
514 {
515 // Indirect draws.
516 DE_ASSERT(static_cast<bool>(m_params.indirectArgs));
517 const auto& indirectArgs = m_params.indirectArgs.get();
518
519 // Check stride and offset validity.
520 DE_ASSERT(indirectArgs.offset % 4u == 0u);
521 DE_ASSERT(indirectArgs.stride % 4u == 0u && (indirectArgs.stride == 0u || indirectArgs.stride >= static_cast<uint32_t>(sizeof(VkDrawMeshTasksIndirectCommandNV))));
522
523 // Prepare struct vector, which will be converted to a buffer with the proper stride and offset later.
524 std::vector<VkDrawMeshTasksIndirectCommandNV> commands;
525 commands.reserve(blockSizes.size());
526
527 std::transform(begin(blockSizes), end(blockSizes), std::back_inserter(commands),
528 [this](uint32_t blockSize) { return VkDrawMeshTasksIndirectCommandNV{blockSize, this->m_params.firstTask}; });
529
530 const auto padding = static_cast<uint32_t>(sizeof(VkDrawMeshTasksIndirectCommandNV));
531 indirectBuffer = makeStridedBuffer(vkd, device, alloc, commands, indirectArgs.offset, indirectArgs.stride, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, padding);
532
533 // Prepare count buffer if needed.
534 if (m_params.drawType == DrawType::DRAW_INDIRECT_COUNT)
535 {
536 DE_ASSERT(static_cast<bool>(m_params.indirectCountLimit));
537 DE_ASSERT(static_cast<bool>(m_params.indirectCountOffset));
538
539 const auto countBufferValue = ((m_params.indirectCountLimit.get() == IndirectCountLimitType::BUFFER_VALUE)
540 ? m_params.drawCount
541 : largeDrawCount);
542
543 const std::vector<uint32_t> singleCount (1u, countBufferValue);
544 countBuffer = makeStridedBuffer(vkd, device, alloc, singleCount, m_params.indirectCountOffset.get(), static_cast<uint32_t>(sizeof(uint32_t)), VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, 0u);
545 }
546 }
547
548 // Submit commands.
549 beginCommandBuffer(vkd, cmdBuffer);
550 beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), scissors.at(0), clearColor);
551
552 vkd.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), 0u, 1u, &descriptorSet.get(), 0u, nullptr);
553 {
554 const char* pcDataPtr = reinterpret_cast<const char*>(&pcData);
555 for (const auto& range : pcRanges)
556 vkd.cmdPushConstants(cmdBuffer, pipelineLayout.get(), range.stageFlags, range.offset, range.size, pcDataPtr + range.offset);
557 }
558 vkd.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.get());
559
560 if (m_params.drawType == DrawType::DRAW)
561 {
562 vkd.cmdDrawMeshTasksNV(cmdBuffer, m_params.drawCount, m_params.firstTask);
563 }
564 else if (m_params.drawType == DrawType::DRAW_INDIRECT)
565 {
566 const auto& indirectArgs = m_params.indirectArgs.get();
567 vkd.cmdDrawMeshTasksIndirectNV(cmdBuffer, indirectBuffer->get(), indirectArgs.offset, m_params.drawCount, indirectArgs.stride);
568 }
569 else if (m_params.drawType == DrawType::DRAW_INDIRECT_COUNT)
570 {
571 const auto& indirectArgs = m_params.indirectArgs.get();
572 const auto& indirectCountOffset = m_params.indirectCountOffset.get();
573 const auto& indirectCountLimit = m_params.indirectCountLimit.get();
574
575 const auto maxCount = ((indirectCountLimit == IndirectCountLimitType::MAX_COUNT)
576 ? m_params.drawCount
577 : largeDrawCount);
578 vkd.cmdDrawMeshTasksIndirectCountNV(cmdBuffer, indirectBuffer->get(), indirectArgs.offset, countBuffer->get(), indirectCountOffset, maxCount, indirectArgs.stride);
579 }
580 else
581 DE_ASSERT(false);
582
583 endRenderPass(vkd, cmdBuffer);
584
585 // Output buffer to extract the color buffer.
586 BufferWithMemoryPtr outBuffer;
587 void* outBufferData = nullptr;
588 {
589 const auto outBufferSize = static_cast<VkDeviceSize>(static_cast<uint32_t>(tcu::getPixelSize(tcuFormat)) * extent.width * extent.height);
590 const auto outBufferUsage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
591 const auto outBufferInfo = makeBufferCreateInfo(outBufferSize, outBufferUsage);
592
593 outBuffer = BufferWithMemoryPtr(new BufferWithMemory(vkd, device, alloc, outBufferInfo, MemoryRequirement::HostVisible));
594 outBufferData = outBuffer->getAllocation().getHostPtr();
595 }
596
597 copyImageToBuffer(vkd, cmdBuffer, colorBuffer->get(), outBuffer->get(), iExtent2D);
598 endCommandBuffer(vkd, cmdBuffer);
599 submitCommandsAndWait(vkd, device, queue, cmdBuffer);
600
601 // Generate reference image and compare.
602 {
603 auto& log = m_context.getTestContext().getLog();
604 auto& outBufferAlloc = outBuffer->getAllocation();
605 tcu::ConstPixelBufferAccess result (tcuFormat, iExtent3D, outBufferData);
606 tcu::TextureLevel referenceLevel (tcuFormat, iExtent3D.x(), iExtent3D.y());
607 const auto reference = referenceLevel.getAccess();
608 const auto setName = de::toString(m_params.drawType) + "_draw_count_" + de::toString(m_params.drawCount) + (m_params.useTask ? "_with_task" : "_no_task");
609 const auto fHeight = static_cast<float>(extent.height);
610 const auto fWidth = static_cast<float>(extent.width);
611
612 invalidateAlloc(vkd, device, outBufferAlloc);
613
614 for (int y = 0; y < iExtent3D.y(); ++y)
615 for (int x = 0; x < iExtent3D.x(); ++x)
616 {
617 const tcu::Vec4 refColor = ((m_params.drawCount == 0u || (m_params.drawType == DrawType::DRAW && y >= static_cast<int>(m_params.drawCount)))
618 ? clearColor
619 : tcu::Vec4(
620 // These match the per-primitive color set by the mesh shader.
621 (static_cast<float>(y) + 0.5f) / fHeight,
622 (static_cast<float>(x) + 0.5f) / fWidth,
623 0.0f,
624 1.0f));
625 reference.setPixel(refColor, x, y);
626 }
627
628 if (!tcu::floatThresholdCompare(log, setName.c_str(), "", reference, result, threshold, tcu::COMPARE_LOG_ON_ERROR))
629 return tcu::TestStatus::fail("Image comparison failed; check log for details");
630 }
631
632 return tcu::TestStatus::pass("Pass");
633 }
634
635 } // anonymous
636
createMeshShaderApiTests(tcu::TestContext & testCtx)637 tcu::TestCaseGroup* createMeshShaderApiTests (tcu::TestContext& testCtx)
638 {
639 GroupPtr mainGroup (new tcu::TestCaseGroup(testCtx, "api", "Mesh Shader API tests"));
640
641 const DrawType drawCases[] =
642 {
643 DrawType::DRAW,
644 DrawType::DRAW_INDIRECT,
645 DrawType::DRAW_INDIRECT_COUNT,
646 };
647
648 const auto extent = getExtent();
649 const uint32_t drawCountCases[] = { 0u, 1u, 2u, extent.height / 2u, extent.height };
650
651 const uint32_t normalStride = static_cast<uint32_t>(sizeof(VkDrawMeshTasksIndirectCommandNV));
652 const uint32_t largeStride = 2u * normalStride + 4u;
653 const uint32_t altOffset = 20u;
654
655 const struct
656 {
657 tcu::Maybe<IndirectArgs> indirectArgs;
658 const char* name;
659 } indirectArgsCases[] =
660 {
661 { tcu::nothing<IndirectArgs>(), "no_indirect_args" },
662
663 // Offset 0, varying strides.
664 { tcu::just(IndirectArgs{ 0u, 0u }), "offset_0_stride_0" },
665 { tcu::just(IndirectArgs{ 0u, normalStride }), "offset_0_stride_normal" },
666 { tcu::just(IndirectArgs{ 0u, largeStride }), "offset_0_stride_large" },
667
668 // Nonzero offset, varying strides.
669 { tcu::just(IndirectArgs{ altOffset, 0u }), "offset_alt_stride_0" },
670 { tcu::just(IndirectArgs{ altOffset, normalStride }), "offset_alt_stride_normal" },
671 { tcu::just(IndirectArgs{ altOffset, largeStride }), "offset_alt_stride_large" },
672 };
673
674 const struct
675 {
676 tcu::Maybe<IndirectCountLimitType> limitType;
677 const char* name;
678 } countLimitCases[] =
679 {
680 { tcu::nothing<IndirectCountLimitType>(), "no_count_limit" },
681 { tcu::just(IndirectCountLimitType::BUFFER_VALUE), "count_limit_buffer" },
682 { tcu::just(IndirectCountLimitType::MAX_COUNT), "count_limit_max_count" },
683 };
684
685 const struct
686 {
687 tcu::Maybe<uint32_t> countOffset;
688 const char* name;
689 } countOffsetCases[] =
690 {
691 { tcu::nothing<uint32_t>(), "no_count_offset" },
692 { tcu::just(uint32_t{0u}), "count_offset_0" },
693 { tcu::just(altOffset), "count_offset_alt" },
694 };
695
696 const struct
697 {
698 bool useTask;
699 const char* name;
700 } taskCases[] =
701 {
702 { false, "no_task_shader" },
703 { true, "with_task_shader" },
704 };
705
706 const struct
707 {
708 uint32_t firstTask;
709 const char* name;
710 } firstTaskCases[] =
711 {
712 { 0u, "first_task_zero" },
713 { 1001u, "first_task_nonzero" },
714 };
715
716 uint32_t seed = 1628678795u;
717
718 for (const auto& drawCase : drawCases)
719 {
720 const auto drawCaseName = de::toString(drawCase);
721 const bool isIndirect = (drawCase != DrawType::DRAW);
722 const bool isIndirectNoCount = (drawCase == DrawType::DRAW_INDIRECT);
723 const bool isIndirectCount = (drawCase == DrawType::DRAW_INDIRECT_COUNT);
724
725 GroupPtr drawGroup(new tcu::TestCaseGroup(testCtx, drawCaseName.c_str(), ""));
726
727 for (const auto& drawCountCase : drawCountCases)
728 {
729 const auto drawCountName = "draw_count_" + de::toString(drawCountCase);
730 GroupPtr drawCountGroup(new tcu::TestCaseGroup(testCtx, drawCountName.c_str(), ""));
731
732 for (const auto& indirectArgsCase : indirectArgsCases)
733 {
734 const bool hasIndirectArgs = static_cast<bool>(indirectArgsCase.indirectArgs);
735 const bool strideZero = (hasIndirectArgs && indirectArgsCase.indirectArgs.get().stride == 0u);
736
737 if (isIndirect != hasIndirectArgs)
738 continue;
739
740 // VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146 and VUID-vkCmdDrawMeshTasksIndirectCountNV-stride-02182.
741 if (((isIndirectNoCount && drawCountCase > 1u) || isIndirectCount) && strideZero)
742 continue;
743
744 GroupPtr indirectArgsGroup(new tcu::TestCaseGroup(testCtx, indirectArgsCase.name, ""));
745
746 for (const auto& countLimitCase : countLimitCases)
747 {
748 const bool hasCountLimit = static_cast<bool>(countLimitCase.limitType);
749
750 if (isIndirectCount != hasCountLimit)
751 continue;
752
753 GroupPtr countLimitGroup(new tcu::TestCaseGroup(testCtx, countLimitCase.name, ""));
754
755 for (const auto& countOffsetCase : countOffsetCases)
756 {
757 const bool hasCountOffsetType = static_cast<bool>(countOffsetCase.countOffset);
758
759 if (isIndirectCount != hasCountOffsetType)
760 continue;
761
762 GroupPtr countOffsetGroup(new tcu::TestCaseGroup(testCtx, countOffsetCase.name, ""));
763
764 for (const auto& taskCase : taskCases)
765 {
766 GroupPtr taskCaseGrp(new tcu::TestCaseGroup(testCtx, taskCase.name, ""));
767
768 for (const auto& firstTaskCase : firstTaskCases)
769 {
770 const TestParams params =
771 {
772 drawCase, // DrawType drawType;
773 seed++, // uint32_t seed;
774 drawCountCase, // uint32_t drawCount;
775 firstTaskCase.firstTask, // uint32_t firstTask;
776 indirectArgsCase.indirectArgs, // tcu::Maybe<IndirectArgs> indirectArgs;
777 countLimitCase.limitType, // tcu::Maybe<IndirectCountLimitType> indirectCountLimit;
778 countOffsetCase.countOffset, // tcu::Maybe<uint32_t> indirectCountOffset;
779 taskCase.useTask, // bool useTask;
780 };
781
782 taskCaseGrp->addChild(new MeshApiCase(testCtx, firstTaskCase.name, "", params));
783 }
784
785 countOffsetGroup->addChild(taskCaseGrp.release());
786 }
787
788 countLimitGroup->addChild(countOffsetGroup.release());
789 }
790
791 indirectArgsGroup->addChild(countLimitGroup.release());
792 }
793
794 drawCountGroup->addChild(indirectArgsGroup.release());
795 }
796
797 drawGroup->addChild(drawCountGroup.release());
798 }
799
800 mainGroup->addChild(drawGroup.release());
801 }
802
803 return mainGroup.release();
804 }
805
806 } // MeshShader
807 } // vkt
808