1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Intel 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 Draw Indexed Tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktDrawIndexedTest.hpp"
26
27 #include "vktTestCaseUtil.hpp"
28 #include "vktDrawTestCaseUtil.hpp"
29
30 #include "vktDrawBaseClass.hpp"
31
32 #include "tcuTestLog.hpp"
33 #include "tcuResource.hpp"
34 #include "tcuImageCompare.hpp"
35 #include "tcuTextureUtil.hpp"
36 #include "tcuRGBA.hpp"
37
38 #include "vkDefs.hpp"
39 #include "vkCmdUtil.hpp"
40
41 enum
42 {
43 VERTEX_OFFSET = 13
44 };
45
46 namespace vkt
47 {
48 namespace Draw
49 {
50 namespace
51 {
52 class DrawIndexed : public DrawTestsBaseClass
53 {
54 public:
55 typedef TestSpecBase TestSpec;
56
57 DrawIndexed (Context &context, TestSpec testSpec);
58 virtual tcu::TestStatus iterate (void);
59 protected:
60 std::vector<deUint32> m_indexes;
61 de::SharedPtr<Buffer> m_indexBuffer;
62 };
63
64 class DrawInstancedIndexed : public DrawIndexed
65 {
66 public:
67 DrawInstancedIndexed (Context &context, TestSpec testSpec);
68 virtual tcu::TestStatus iterate (void);
69 };
70
DrawIndexed(Context & context,TestSpec testSpec)71 DrawIndexed::DrawIndexed (Context &context, TestSpec testSpec)
72 : DrawTestsBaseClass(context, testSpec.shaders[glu::SHADERTYPE_VERTEX], testSpec.shaders[glu::SHADERTYPE_FRAGMENT], testSpec.groupParams, testSpec.topology)
73 {
74 switch (m_topology)
75 {
76 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
77 m_indexes.push_back(0);
78 m_indexes.push_back(0);
79 m_indexes.push_back(2);
80 m_indexes.push_back(0);
81 m_indexes.push_back(6);
82 m_indexes.push_back(6);
83 m_indexes.push_back(0);
84 m_indexes.push_back(7);
85 break;
86 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
87 m_indexes.push_back(0);
88 m_indexes.push_back(0);
89 m_indexes.push_back(2);
90 m_indexes.push_back(0);
91 m_indexes.push_back(6);
92 m_indexes.push_back(5);
93 m_indexes.push_back(0);
94 m_indexes.push_back(7);
95 break;
96
97 case vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
98 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
99 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
100 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
101 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
102 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
103 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
104 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
105 case vk::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
106 case vk::VK_PRIMITIVE_TOPOLOGY_LAST:
107 DE_FATAL("Topology not implemented");
108 break;
109 default:
110 DE_FATAL("Unknown topology");
111 break;
112 }
113
114 for (int unusedIdx = 0; unusedIdx < VERTEX_OFFSET; unusedIdx++)
115 {
116 m_data.push_back(VertexElementData(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), -1));
117 }
118
119 int vertexIndex = VERTEX_OFFSET;
120
121 m_data.push_back(VertexElementData(tcu::Vec4( -0.3f, 0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
122 m_data.push_back(VertexElementData(tcu::Vec4( -1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
123 m_data.push_back(VertexElementData(tcu::Vec4( -0.3f, -0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
124 m_data.push_back(VertexElementData(tcu::Vec4( 1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
125 m_data.push_back(VertexElementData(tcu::Vec4( -0.3f, -0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
126 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f, 0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
127 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f, -0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
128 m_data.push_back(VertexElementData(tcu::Vec4( 0.3f, 0.3f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), vertexIndex++));
129
130 m_data.push_back(VertexElementData(tcu::Vec4( -1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec(), -1));
131
132 initialize();
133 }
134
iterate(void)135 tcu::TestStatus DrawIndexed::iterate (void)
136 {
137 tcu::TestLog& log = m_context.getTestContext().getLog();
138 const vk::VkQueue queue = m_context.getUniversalQueue();
139 const vk::VkDevice device = m_context.getDevice();
140
141 const vk::VkDeviceSize dataSize = m_indexes.size() * sizeof(deUint32);
142 m_indexBuffer = Buffer::createAndAlloc( m_vk, m_context.getDevice(),
143 BufferCreateInfo(dataSize,
144 vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT),
145 m_context.getDefaultAllocator(),
146 vk::MemoryRequirement::HostVisible);
147
148 deUint8* ptr = reinterpret_cast<deUint8*>(m_indexBuffer->getBoundMemory().getHostPtr());
149 deMemcpy(ptr, &m_indexes[0], static_cast<size_t>(dataSize));
150 vk::flushAlloc(m_vk, m_context.getDevice(), m_indexBuffer->getBoundMemory());
151
152 const vk::VkDeviceSize vertexBufferOffset = 0;
153 const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
154 const vk::VkBuffer indexBuffer = m_indexBuffer->object();
155
156 #ifndef CTS_USES_VULKANSC
157 if (m_groupParams->useSecondaryCmdBuffer)
158 {
159 // record secondary command buffer
160 if (m_groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
161 {
162 beginSecondaryCmdBuffer(m_vk, vk::VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT);
163 beginDynamicRender(*m_secCmdBuffer);
164 }
165 else
166 beginSecondaryCmdBuffer(m_vk);
167
168 m_vk.cmdBindVertexBuffers(*m_secCmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
169 m_vk.cmdBindIndexBuffer(*m_secCmdBuffer, indexBuffer, 0, vk::VK_INDEX_TYPE_UINT32);
170 m_vk.cmdBindPipeline(*m_secCmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
171 m_vk.cmdDrawIndexed(*m_secCmdBuffer, 6, 1, 2, VERTEX_OFFSET, 0);
172
173 if (m_groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
174 endDynamicRender(*m_secCmdBuffer);
175
176 endCommandBuffer(m_vk, *m_secCmdBuffer);
177
178 // record primary command buffer
179 beginCommandBuffer(m_vk, *m_cmdBuffer, 0u);
180 preRenderBarriers();
181
182 if (!m_groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
183 beginDynamicRender(*m_cmdBuffer, vk::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
184
185 m_vk.cmdExecuteCommands(*m_cmdBuffer, 1u, &*m_secCmdBuffer);
186
187 if (!m_groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
188 endDynamicRender(*m_cmdBuffer);
189
190 endCommandBuffer(m_vk, *m_cmdBuffer);
191 }
192 else if (m_groupParams->useDynamicRendering)
193 {
194 beginCommandBuffer(m_vk, *m_cmdBuffer, 0u);
195 preRenderBarriers();
196 beginDynamicRender(*m_cmdBuffer);
197
198 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
199 m_vk.cmdBindIndexBuffer(*m_cmdBuffer, indexBuffer, 0, vk::VK_INDEX_TYPE_UINT32);
200 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
201 m_vk.cmdDrawIndexed(*m_cmdBuffer, 6, 1, 2, VERTEX_OFFSET, 0);
202
203 endDynamicRender(*m_cmdBuffer);
204 endCommandBuffer(m_vk, *m_cmdBuffer);
205 }
206 #endif // CTS_USES_VULKANSC
207
208 if (!m_groupParams->useDynamicRendering)
209 {
210 beginCommandBuffer(m_vk, *m_cmdBuffer, 0u);
211 preRenderBarriers();
212 beginLegacyRender(*m_cmdBuffer);
213
214 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
215 m_vk.cmdBindIndexBuffer(*m_cmdBuffer, indexBuffer, 0, vk::VK_INDEX_TYPE_UINT32);
216 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
217 m_vk.cmdDrawIndexed(*m_cmdBuffer, 6, 1, 2, VERTEX_OFFSET, 0);
218
219 endLegacyRender(*m_cmdBuffer);
220 endCommandBuffer(m_vk, *m_cmdBuffer);
221 }
222
223 submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
224
225 // Validation
226 tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5f + static_cast<float>(WIDTH)), (int)(0.5f + static_cast<float>(HEIGHT)));
227 referenceFrame.allocLevel(0);
228
229 const deInt32 frameWidth = referenceFrame.getWidth();
230 const deInt32 frameHeight = referenceFrame.getHeight();
231
232 tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
233
234 ReferenceImageCoordinates refCoords;
235
236 for (int y = 0; y < frameHeight; y++)
237 {
238 const float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
239
240 for (int x = 0; x < frameWidth; x++)
241 {
242 const float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
243
244 if ((yCoord >= refCoords.bottom &&
245 yCoord <= refCoords.top &&
246 xCoord >= refCoords.left &&
247 xCoord <= refCoords.right))
248 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), x, y);
249 }
250 }
251
252 const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
253 const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
254 vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
255
256 qpTestResult res = QP_TEST_RESULT_PASS;
257
258 if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
259 referenceFrame.getLevel(0), renderedFrame, 0.05f,
260 tcu::COMPARE_LOG_RESULT)) {
261 res = QP_TEST_RESULT_FAIL;
262 }
263
264 return tcu::TestStatus(res, qpGetTestResultName(res));
265 }
266
DrawInstancedIndexed(Context & context,TestSpec testSpec)267 DrawInstancedIndexed::DrawInstancedIndexed (Context &context, TestSpec testSpec)
268 : DrawIndexed (context, testSpec)
269 {
270 }
271
iterate(void)272 tcu::TestStatus DrawInstancedIndexed::iterate (void)
273 {
274 tcu::TestLog& log = m_context.getTestContext().getLog();
275 const vk::VkQueue queue = m_context.getUniversalQueue();
276 const vk::VkDevice device = m_context.getDevice();
277
278 beginCommandBuffer(m_vk, *m_cmdBuffer, 0u);
279 preRenderBarriers();
280
281 #ifndef CTS_USES_VULKANSC
282 if (m_groupParams->useDynamicRendering)
283 beginDynamicRender(*m_cmdBuffer);
284 else
285 beginLegacyRender(*m_cmdBuffer);
286 #else
287 beginLegacyRender(*m_cmdBuffer);
288 #endif // CTS_USES_VULKANSC
289
290 const vk::VkDeviceSize dataSize = m_indexes.size() * sizeof(deUint32);
291 m_indexBuffer = Buffer::createAndAlloc( m_vk, m_context.getDevice(),
292 BufferCreateInfo(dataSize,
293 vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT),
294 m_context.getDefaultAllocator(),
295 vk::MemoryRequirement::HostVisible);
296
297 deUint8* ptr = reinterpret_cast<deUint8*>(m_indexBuffer->getBoundMemory().getHostPtr());
298
299 deMemcpy(ptr, &m_indexes[0], static_cast<size_t>(dataSize));
300 vk::flushAlloc(m_vk, m_context.getDevice(), m_indexBuffer->getBoundMemory());
301
302 const vk::VkDeviceSize vertexBufferOffset = 0;
303 const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
304 const vk::VkBuffer indexBuffer = m_indexBuffer->object();
305
306 m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
307 m_vk.cmdBindIndexBuffer(*m_cmdBuffer, indexBuffer, 0, vk::VK_INDEX_TYPE_UINT32);
308 m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
309
310 switch (m_topology)
311 {
312 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
313 m_vk.cmdDrawIndexed(*m_cmdBuffer, 6, 4, 2, VERTEX_OFFSET, 2);
314 break;
315 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
316 m_vk.cmdDrawIndexed(*m_cmdBuffer, 4, 4, 2, VERTEX_OFFSET, 2);
317 break;
318 case vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
319 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
320 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
321 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
322 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
323 case vk::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
324 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
325 case vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
326 case vk::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
327 case vk::VK_PRIMITIVE_TOPOLOGY_LAST:
328 DE_FATAL("Topology not implemented");
329 break;
330 default:
331 DE_FATAL("Unknown topology");
332 break;
333 }
334
335 #ifndef CTS_USES_VULKANSC
336 if (m_groupParams->useDynamicRendering)
337 endDynamicRender(*m_cmdBuffer);
338 else
339 endLegacyRender(*m_cmdBuffer);
340 #else
341 endLegacyRender(*m_cmdBuffer);
342 #endif // CTS_USES_VULKANSC
343
344 endCommandBuffer(m_vk, *m_cmdBuffer);
345
346 submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
347
348 // Validation
349 VK_CHECK(m_vk.queueWaitIdle(queue));
350
351 tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5f + static_cast<float>(WIDTH)), (int)(0.5f + static_cast<float>(HEIGHT)));
352 referenceFrame.allocLevel(0);
353
354 const deInt32 frameWidth = referenceFrame.getWidth();
355 const deInt32 frameHeight = referenceFrame.getHeight();
356
357 tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
358
359 ReferenceImageInstancedCoordinates refInstancedCoords;
360
361 for (int y = 0; y < frameHeight; y++)
362 {
363 const float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
364
365 for (int x = 0; x < frameWidth; x++)
366 {
367 const float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
368
369 if ((yCoord >= refInstancedCoords.bottom &&
370 yCoord <= refInstancedCoords.top &&
371 xCoord >= refInstancedCoords.left &&
372 xCoord <= refInstancedCoords.right))
373 referenceFrame.getLevel(0).setPixel(tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), x, y);
374 }
375 }
376
377 const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
378 const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
379 vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
380
381 qpTestResult res = QP_TEST_RESULT_PASS;
382
383 if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
384 referenceFrame.getLevel(0), renderedFrame, 0.05f,
385 tcu::COMPARE_LOG_RESULT)) {
386 res = QP_TEST_RESULT_FAIL;
387 }
388
389 return tcu::TestStatus(res, qpGetTestResultName(res));
390 }
391
checkSupport(Context & context,DrawIndexed::TestSpec testSpec)392 void checkSupport(Context& context, DrawIndexed::TestSpec testSpec)
393 {
394 if (testSpec.groupParams->useDynamicRendering)
395 context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
396 }
397
398 } // anonymous
399
DrawIndexedTests(tcu::TestContext & testCtx,const SharedGroupParams groupParams)400 DrawIndexedTests::DrawIndexedTests (tcu::TestContext &testCtx, const SharedGroupParams groupParams)
401 : TestCaseGroup (testCtx, "indexed_draw", "drawing indexed geometry")
402 , m_groupParams (groupParams)
403 {
404 /* Left blank on purpose */
405 }
406
~DrawIndexedTests(void)407 DrawIndexedTests::~DrawIndexedTests (void) {}
408
init(void)409 void DrawIndexedTests::init (void)
410 {
411 {
412 DrawIndexed::TestSpec testSpec
413 {
414 {
415 { glu::SHADERTYPE_VERTEX, "vulkan/draw/VertexFetch.vert" },
416 { glu::SHADERTYPE_FRAGMENT, "vulkan/draw/VertexFetch.frag" }
417 },
418 vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
419 m_groupParams
420 };
421
422 addChild(new InstanceFactory<DrawIndexed, FunctionSupport1<DrawIndexed::TestSpec> >
423 (m_testCtx, "draw_indexed_triangle_list", "Draws indexed triangle list", testSpec, FunctionSupport1<DrawIndexed::TestSpec>::Args(checkSupport, testSpec)));
424 testSpec.topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
425 addChild(new InstanceFactory<DrawIndexed, FunctionSupport1<DrawIndexed::TestSpec> >
426 (m_testCtx, "draw_indexed_triangle_strip", "Draws indexed triangle strip", testSpec, FunctionSupport1<DrawIndexed::TestSpec>::Args(checkSupport, testSpec)));
427 }
428 {
429 DrawInstancedIndexed::TestSpec testSpec
430 {
431 {
432 { glu::SHADERTYPE_VERTEX, "vulkan/draw/VertexFetchInstancedFirstInstance.vert" },
433 { glu::SHADERTYPE_FRAGMENT, "vulkan/draw/VertexFetch.frag" }
434 },
435 vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
436 m_groupParams
437 };
438
439 addChild(new InstanceFactory<DrawInstancedIndexed, FunctionSupport1<DrawInstancedIndexed::TestSpec> >
440 (m_testCtx, "draw_instanced_indexed_triangle_list", "Draws indexed triangle list", testSpec, FunctionSupport1<DrawInstancedIndexed::TestSpec>::Args(checkSupport, testSpec)));
441 testSpec.topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
442 addChild(new InstanceFactory<DrawInstancedIndexed, FunctionSupport1<DrawInstancedIndexed::TestSpec> >
443 (m_testCtx, "draw_instanced_indexed_triangle_strip", "Draws indexed triangle strip", testSpec, FunctionSupport1<DrawInstancedIndexed::TestSpec>::Args(checkSupport, testSpec)));
444 }
445 }
446
447 } // DrawTests
448 } // vkt
449