1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Intel Corporation
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and/or associated documentation files (the
10 * "Materials"), to deal in the Materials without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sublicense, and/or sell copies of the Materials, and to
13 * permit persons to whom the Materials are furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice(s) and this permission notice shall be included
17 * in all copies or substantial portions of the Materials.
19 * The Materials are Confidential Information as defined by the
20 * Khronos Membership Agreement until designated non-confidential by Khronos,
21 * at which point this condition clause shall be removed.
23 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
26 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
27 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
28 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
29 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
33 * \brief Vulkan Occlusion Query Tests
34 *//*--------------------------------------------------------------------*/
36 #include "vktQueryPoolOcclusionTests.hpp"
38 #include "vktTestCase.hpp"
40 #include "vktQueryPoolImageObjectUtil.hpp"
41 #include "vktQueryPoolBufferObjectUtil.hpp"
42 #include "vktQueryPoolCreateInfoUtil.hpp"
43 #include "vkBuilderUtil.hpp"
44 #include "vkRefUtil.hpp"
45 #include "vkPrograms.hpp"
47 #include "tcuTestLog.hpp"
48 #include "tcuResource.hpp"
49 #include "tcuImageCompare.hpp"
50 #include "tcuCommandLine.hpp"
52 using namespace vkt::QueryPool;
59 StateObjects (const vk::DeviceInterface&vk, vkt::Context &context, const int numVertices, vk::VkPrimitiveTopology primitive);
60 void setVertices (const vk::DeviceInterface&vk, std::vector<tcu::Vec4> vertices);
68 vkt::Context &m_context;
70 vk::Move<vk::VkPipeline> m_pipeline;
71 vk::Move<vk::VkPipelineLayout> m_pipelineLayout;
73 de::SharedPtr<Image> m_colorAttachmentImage, m_DepthImage;
74 vk::Move<vk::VkImageView> m_attachmentView;
75 vk::Move<vk::VkImageView> m_depthiew;
77 vk::Move<vk::VkRenderPass> m_renderPass;
78 vk::Move<vk::VkFramebuffer> m_framebuffer;
80 de::SharedPtr<Buffer> m_vertexBuffer;
82 vk::VkFormat m_colorAttachmentFormat;
85 StateObjects::StateObjects (const vk::DeviceInterface&vk, vkt::Context &context, const int numVertices, vk::VkPrimitiveTopology primitive)
87 , m_colorAttachmentFormat(vk::VK_FORMAT_R8G8B8A8_UNORM)
90 vk::VkFormat depthFormat = vk::VK_FORMAT_D16_UNORM;
91 const vk::VkDevice device = m_context.getDevice();
93 //attachment images and views
95 vk::VkExtent3D imageExtent =
102 const ImageCreateInfo colorImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
103 vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
105 m_colorAttachmentImage = Image::createAndAlloc(vk, device, colorImageCreateInfo, m_context.getDefaultAllocator());
107 const ImageViewCreateInfo attachmentViewInfo(m_colorAttachmentImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
108 m_attachmentView = vk::createImageView(vk, device, &attachmentViewInfo);
110 ImageCreateInfo depthImageCreateInfo(vk::VK_IMAGE_TYPE_2D, depthFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
111 vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
113 m_DepthImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator());
115 // Construct a depth view from depth image
116 const ImageViewCreateInfo depthViewInfo(m_DepthImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, depthFormat);
117 m_depthiew = vk::createImageView(vk, device, &depthViewInfo);
121 // Renderpass and Framebuffer
123 RenderPassCreateInfo renderPassCreateInfo;
124 renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, // format
125 vk::VK_SAMPLE_COUNT_1_BIT, // samples
126 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
127 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
128 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
129 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
130 vk::VK_IMAGE_LAYOUT_GENERAL, // initialLauout
131 vk::VK_IMAGE_LAYOUT_GENERAL)); // finalLayout
133 renderPassCreateInfo.addAttachment(AttachmentDescription(depthFormat, // format
134 vk::VK_SAMPLE_COUNT_1_BIT, // samples
135 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
136 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
137 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
138 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
139 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
140 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
142 const vk::VkAttachmentReference colorAttachmentReference =
145 vk::VK_IMAGE_LAYOUT_GENERAL // layout
148 const vk::VkAttachmentReference depthAttachmentReference =
151 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // layout
154 renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
157 DE_NULL, // pInputAttachments
159 &colorAttachmentReference, // pColorAttachments
160 DE_NULL, // pResolveAttachments
161 depthAttachmentReference, // depthStencilAttachment
163 DE_NULL)); // preserveAttachments
165 m_renderPass = vk::createRenderPass(vk, device, &renderPassCreateInfo);
167 std::vector<vk::VkImageView> attachments(2);
168 attachments[0] = *m_attachmentView;
169 attachments[1] = *m_depthiew;
171 FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
172 m_framebuffer = vk::createFramebuffer(vk, device, &framebufferCreateInfo);
178 vk::Unique<vk::VkShaderModule> vs(vk::createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
179 vk::Unique<vk::VkShaderModule> fs(vk::createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
181 const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
183 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
184 m_pipelineLayout = vk::createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
186 const vk::VkVertexInputBindingDescription vf_binding_desc =
189 4 * (deUint32)sizeof(float), // stride;
190 vk::VK_VERTEX_INPUT_RATE_VERTEX // inputRate
193 const vk::VkVertexInputAttributeDescription vf_attribute_desc =
197 vk::VK_FORMAT_R32G32B32A32_SFLOAT, // format;
201 const vk::VkPipelineVertexInputStateCreateInfo vf_info =
203 vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
205 0u, // vertexBindingDescriptionCount;
206 1, // pVertexBindingDescriptions;
207 &vf_binding_desc, // vertexAttributeDescriptionCount;
208 1, // pVertexAttributeDescriptions;
212 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0);
213 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT));
214 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT));
215 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(primitive));
216 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
217 const vk::VkViewport viewport =
221 WIDTH, // float width;
222 HEIGHT, // float height;
223 0.0f, // float minDepth;
224 1.0f // float maxDepth;
227 const vk::VkRect2D scissor =
232 }, // VkOffset2D offset;
234 WIDTH, // deInt32 width;
235 HEIGHT, // deInt32 height
236 }, // VkExtent2D extent;
238 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector<vk::VkViewport>(1, viewport), std::vector<vk::VkRect2D>(1, scissor)));
239 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState(true, true, vk::VK_COMPARE_OP_GREATER_OR_EQUAL));
240 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
241 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
242 pipelineCreateInfo.addState(vf_info);
243 m_pipeline = vk::createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
248 const size_t kBufferSize = numVertices * sizeof(tcu::Vec4);
249 m_vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(kBufferSize, vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
253 void StateObjects::setVertices (const vk::DeviceInterface&vk, std::vector<tcu::Vec4> vertices)
255 const vk::VkDevice device = m_context.getDevice();
257 tcu::Vec4 *ptr = reinterpret_cast<tcu::Vec4*>(m_vertexBuffer->getBoundMemory().getHostPtr());
258 std::copy(vertices.begin(), vertices.end(), ptr);
260 vk::flushMappedMemoryRange(vk, device, m_vertexBuffer->getBoundMemory().getMemory(), m_vertexBuffer->getBoundMemory().getOffset(), vertices.size() * sizeof(vertices[0]));
263 enum OcclusionQueryResultSize
269 enum OcclusionQueryWait
276 enum OcclusionQueryResultsMode
282 struct OcclusionQueryTestVector
284 vk::VkQueryControlFlags queryControlFlags;
285 OcclusionQueryResultSize queryResultSize;
286 OcclusionQueryWait queryWait;
287 OcclusionQueryResultsMode queryResultsMode;
288 vk::VkDeviceSize queryResultsStride;
289 bool queryResultsAvailability;
290 vk::VkPrimitiveTopology primitiveRopology;
293 class BasicOcclusionQueryTestInstance : public vkt::TestInstance
296 BasicOcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector);
297 ~BasicOcclusionQueryTestInstance (void);
299 tcu::TestStatus iterate (void);
303 NUM_QUERIES_IN_POOL = 2,
304 QUERY_INDEX_CAPTURE_EMPTY = 0,
305 QUERY_INDEX_CAPTURE_DRAWCALL = 1,
306 NUM_VERTICES_IN_DRAWCALL = 3
309 OcclusionQueryTestVector m_testVector;
310 StateObjects* m_stateObjects;
311 vk::VkQueryPool m_queryPool;
314 BasicOcclusionQueryTestInstance::BasicOcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector)
315 : TestInstance (context)
316 , m_testVector (testVector)
317 , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, NUM_VERTICES_IN_DRAWCALL, m_testVector.primitiveRopology))
319 DE_ASSERT(testVector.queryResultSize == RESULT_SIZE_64_BIT
320 && testVector.queryWait == WAIT_QUEUE
321 && testVector.queryResultsMode == RESULTS_MODE_GET
322 && testVector.queryResultsStride == sizeof(deUint64)
323 && testVector.queryResultsAvailability == false
324 && testVector.primitiveRopology == vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST);
326 const vk::VkDevice device = m_context.getDevice();
327 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
329 const vk::VkQueryPoolCreateInfo queryPoolCreateInfo =
331 vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
334 vk::VK_QUERY_TYPE_OCCLUSION,
338 VK_CHECK(vk.createQueryPool(device, &queryPoolCreateInfo, /*pAllocator*/ DE_NULL, &m_queryPool));
340 std::vector<tcu::Vec4> vertices(NUM_VERTICES_IN_DRAWCALL);
341 vertices[0] = tcu::Vec4(0.5, 0.5, 0.0, 1.0);
342 vertices[1] = tcu::Vec4(0.5, 0.0, 0.0, 1.0);
343 vertices[2] = tcu::Vec4(0.0, 0.5, 0.0, 1.0);
344 m_stateObjects->setVertices(vk, vertices);
347 BasicOcclusionQueryTestInstance::~BasicOcclusionQueryTestInstance (void)
350 delete m_stateObjects;
352 if (m_queryPool != DE_NULL)
354 const vk::VkDevice device = m_context.getDevice();
355 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
357 vk.destroyQueryPool(device, m_queryPool, /*pAllocator*/ DE_NULL);
361 tcu::TestStatus BasicOcclusionQueryTestInstance::iterate (void)
363 tcu::TestLog &log = m_context.getTestContext().getLog();
364 const vk::VkDevice device = m_context.getDevice();
365 const vk::VkQueue queue = m_context.getUniversalQueue();
366 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
368 const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
369 vk::Move<vk::VkCommandPool> cmdPool = vk::createCommandPool(vk, device, &cmdPoolCreateInfo);
371 const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
373 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
374 DE_NULL, // const void* pNext;
375 *cmdPool, // VkCommandPool commandPool;
376 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
377 1u, // deUint32 bufferCount;
379 vk::Unique<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
380 const CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
382 vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
384 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
385 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
387 std::vector<vk::VkClearValue> renderPassClearValues(2);
388 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue));
390 const vk::VkRect2D renderArea =
393 { StateObjects::WIDTH, StateObjects::HEIGHT }
396 RenderPassBeginInfo renderPassBegin(*m_stateObjects->m_renderPass, *m_stateObjects->m_framebuffer, renderArea, renderPassClearValues);
398 vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL);
400 vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
402 vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_stateObjects->m_pipeline);
404 vk::VkBuffer vertexBuffer = m_stateObjects->m_vertexBuffer->object();
405 const vk::VkDeviceSize vertexBufferOffset = 0;
406 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
408 vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_EMPTY, m_testVector.queryControlFlags);
409 vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_EMPTY);
411 vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_DRAWCALL, m_testVector.queryControlFlags);
412 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, 0, 0);
413 vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_DRAWCALL);
415 vk.cmdEndRenderPass(*cmdBuffer);
417 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
419 vk.endCommandBuffer(*cmdBuffer);
421 // Submit command buffer
422 const vk::VkSubmitInfo submitInfo =
424 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
425 DE_NULL, // const void* pNext;
426 0, // deUint32 waitSemaphoreCount;
427 DE_NULL, // const VkSemaphore* pWaitSemaphores;
428 1, // deUint32 commandBufferCount;
429 &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
430 0, // deUint32 signalSemaphoreCount;
431 DE_NULL // const VkSemaphore* pSignalSemaphores;
433 vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
435 VK_CHECK(vk.queueWaitIdle(queue));
437 deUint64 queryResults[NUM_QUERIES_IN_POOL] = { 0 };
438 size_t queryResultsSize = sizeof(queryResults);
440 vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, NUM_QUERIES_IN_POOL, queryResultsSize, queryResults, sizeof(queryResults[0]), vk::VK_QUERY_RESULT_64_BIT);
442 if (queryResult == vk::VK_NOT_READY)
444 TCU_FAIL("Query result not avaliable, but vkWaitIdle() was called.");
447 VK_CHECK(queryResult);
449 log << tcu::TestLog::Section("OcclusionQueryResults",
450 "Occlusion query results");
451 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(queryResults); ++ndx)
453 log << tcu::TestLog::Message << "query[ slot == " << ndx
454 << "] result == " << queryResults[ndx] << tcu::TestLog::EndMessage;
459 for (int queryNdx = 0; queryNdx < DE_LENGTH_OF_ARRAY(queryResults); ++queryNdx)
462 deUint64 expectedValue;
466 case QUERY_INDEX_CAPTURE_EMPTY:
469 case QUERY_INDEX_CAPTURE_DRAWCALL:
470 expectedValue = NUM_VERTICES_IN_DRAWCALL;
474 if ((m_testVector.queryControlFlags & vk::VK_QUERY_CONTROL_PRECISE_BIT) || expectedValue == 0)
476 // require precise value
477 if (queryResults[queryNdx] != expectedValue)
479 log << tcu::TestLog::Message << "vkGetQueryPoolResults returned "
480 "wrong value of query for index "
481 << queryNdx << ", expected " << expectedValue << ", got "
482 << queryResults[0] << "." << tcu::TestLog::EndMessage;
488 // require imprecize value > 0
489 if (queryResults[queryNdx] == 0)
491 log << tcu::TestLog::Message << "vkGetQueryPoolResults returned "
492 "wrong value of query for index "
493 << queryNdx << ", expected any non-zero value, got "
494 << queryResults[0] << "." << tcu::TestLog::EndMessage;
499 log << tcu::TestLog::EndSection;
501 const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
503 tcu::ConstPixelBufferAccess resultImageAccess = m_stateObjects->m_colorAttachmentImage->readSurface(
504 queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL,
505 zeroOffset, StateObjects::HEIGHT, StateObjects::WIDTH, vk::VK_IMAGE_ASPECT_COLOR_BIT);
507 log << tcu::TestLog::Image("Result", "Result", resultImageAccess);
511 return tcu::TestStatus(QP_TEST_RESULT_PASS, "Query result verification passed");
513 return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Query result verification failed");
516 class OcclusionQueryTestInstance : public vkt::TestInstance
519 OcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector);
520 ~OcclusionQueryTestInstance (void);
522 tcu::TestStatus iterate (void);
524 vk::Move<vk::VkCommandBuffer> recordRender (vk::VkCommandPool commandPool);
525 vk::Move<vk::VkCommandBuffer> recordCopyResults (vk::VkCommandPool commandPool);
527 void captureResults (deUint64* retResults, deUint64* retAvailability, bool allowNotReady);
528 void logResults (const deUint64* results, const deUint64* availability);
529 bool validateResults (const deUint64* results, const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology);
530 void logRenderTarget (void);
534 NUM_QUERIES_IN_POOL = 3,
535 QUERY_INDEX_CAPTURE_ALL = 0,
536 QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED = 1,
537 QUERY_INDEX_CAPTURE_OCCLUDED = 2
541 NUM_VERTICES_IN_DRAWCALL = 3,
542 NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL = 3,
543 NUM_VERTICES_IN_OCCLUDER_DRAWCALL = 3,
544 NUM_VERTICES = NUM_VERTICES_IN_DRAWCALL + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL + NUM_VERTICES_IN_OCCLUDER_DRAWCALL
549 START_VERTEX_PARTIALLY_OCCLUDED = START_VERTEX + NUM_VERTICES_IN_DRAWCALL,
550 START_VERTEX_OCCLUDER = START_VERTEX_PARTIALLY_OCCLUDED + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL
553 OcclusionQueryTestVector m_testVector;
555 const vk::VkQueryResultFlags m_queryResultFlags;
557 StateObjects* m_stateObjects;
558 vk::VkQueryPool m_queryPool;
559 de::SharedPtr<Buffer> m_queryPoolResultsBuffer;
561 vk::Move<vk::VkCommandPool> m_commandPool;
562 vk::Move<vk::VkCommandBuffer> m_renderCommandBuffer;
563 vk::Move<vk::VkCommandBuffer> m_copyResultsCommandBuffer;
566 OcclusionQueryTestInstance::OcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector)
567 : vkt::TestInstance (context)
568 , m_testVector (testVector)
569 , m_queryResultFlags ((m_testVector.queryWait == WAIT_QUERY ? vk::VK_QUERY_RESULT_WAIT_BIT : 0)
570 | (m_testVector.queryResultSize == RESULT_SIZE_64_BIT ? vk::VK_QUERY_RESULT_64_BIT : 0)
571 | (m_testVector.queryResultsAvailability ? vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT : 0))
572 , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, NUM_VERTICES_IN_DRAWCALL + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL + NUM_VERTICES_IN_OCCLUDER_DRAWCALL, m_testVector.primitiveRopology))
574 const vk::VkDevice device = m_context.getDevice();
575 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
577 const vk::VkQueryPoolCreateInfo queryPoolCreateInfo =
579 vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
582 vk::VK_QUERY_TYPE_OCCLUSION,
587 VK_CHECK(vk.createQueryPool(device, &queryPoolCreateInfo, /*pAllocator*/ DE_NULL, &m_queryPool));
589 if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
591 const vk::VkDeviceSize resultsBufferSize = m_testVector.queryResultsStride * NUM_QUERIES_IN_POOL;
592 m_queryPoolResultsBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(resultsBufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
595 const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
596 m_commandPool = vk::createCommandPool(vk, device, &cmdPoolCreateInfo);
597 m_renderCommandBuffer = recordRender(*m_commandPool);
599 if (m_testVector.queryWait == WAIT_QUEUE && m_testVector.queryResultsMode == RESULTS_MODE_COPY)
601 m_copyResultsCommandBuffer = recordCopyResults(*m_commandPool);
605 OcclusionQueryTestInstance::~OcclusionQueryTestInstance (void)
607 const vk::VkDevice device = m_context.getDevice();
610 delete m_stateObjects;
612 if (m_queryPool != DE_NULL)
614 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
615 vk.destroyQueryPool(device, m_queryPool, /*pAllocator*/ DE_NULL);
619 tcu::TestStatus OcclusionQueryTestInstance::iterate (void)
621 const vk::VkQueue queue = m_context.getUniversalQueue();
622 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
623 tcu::TestLog& log = m_context.getTestContext().getLog();
624 std::vector<tcu::Vec4> vertices (NUM_VERTICES);
627 vertices[START_VERTEX + 0] = tcu::Vec4( 0.5, 0.5, 0.5, 1.0);
628 vertices[START_VERTEX + 1] = tcu::Vec4( 0.5, -0.5, 0.5, 1.0);
629 vertices[START_VERTEX + 2] = tcu::Vec4(-0.5, 0.5, 0.5, 1.0);
630 // 2nd triangle - partially occluding the scene
631 vertices[START_VERTEX_PARTIALLY_OCCLUDED + 0] = tcu::Vec4(-0.5, -0.5, 1.0, 1.0);
632 vertices[START_VERTEX_PARTIALLY_OCCLUDED + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
633 vertices[START_VERTEX_PARTIALLY_OCCLUDED + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
634 // 3nd triangle - fully occluding the scene
635 vertices[START_VERTEX_OCCLUDER + 0] = tcu::Vec4( 0.5, 0.5, 1.0, 1.0);
636 vertices[START_VERTEX_OCCLUDER + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
637 vertices[START_VERTEX_OCCLUDER + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
639 m_stateObjects->setVertices(vk, vertices);
642 const vk::VkSubmitInfo submitInfo =
644 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
645 DE_NULL, // const void* pNext;
646 0, // deUint32 waitSemaphoreCount;
647 DE_NULL, // const VkSemaphore* pWaitSemaphores;
648 1, // deUint32 commandBufferCount;
649 &m_renderCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
650 0, // deUint32 signalSemaphoreCount;
651 DE_NULL // const VkSemaphore* pSignalSemaphores;
653 vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
656 if (m_testVector.queryWait == WAIT_QUEUE)
658 VK_CHECK(vk.queueWaitIdle(queue));
660 if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
662 // In case of WAIT_QUEUE test variant, the previously submitted m_renderCommandBuffer did not
663 // contain vkCmdCopyQueryResults, so additional cmd buffer is needed.
665 // In the case of WAIT_NONE or WAIT_QUERY, vkCmdCopyQueryResults is stored in m_renderCommandBuffer.
667 const vk::VkSubmitInfo submitInfo =
669 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
670 DE_NULL, // const void* pNext;
671 0, // deUint32 waitSemaphoreCount;
672 DE_NULL, // const VkSemaphore* pWaitSemaphores;
673 1, // deUint32 commandBufferCount;
674 &m_copyResultsCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
675 0, // deUint32 signalSemaphoreCount;
676 DE_NULL // const VkSemaphore* pSignalSemaphores;
678 vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
682 if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
684 // In case of vkCmdCopyQueryResults is used, test must always wait for it
685 // to complete before we can read the result buffer.
687 VK_CHECK(vk.queueWaitIdle(queue));
690 deUint64 queryResults [NUM_QUERIES_IN_POOL];
691 deUint64 queryAvailability [NUM_QUERIES_IN_POOL];
693 // Allow not ready results only if nobody waited before getting the query results
694 bool allowNotReady = (m_testVector.queryWait == WAIT_NONE);
696 captureResults(queryResults, queryAvailability, allowNotReady);
698 log << tcu::TestLog::Section("OcclusionQueryResults", "Occlusion query results");
700 logResults(queryResults, queryAvailability);
701 bool passed = validateResults(queryResults, queryAvailability, allowNotReady, m_testVector.primitiveRopology);
703 log << tcu::TestLog::EndSection;
709 return tcu::TestStatus(QP_TEST_RESULT_PASS, "Query result verification passed");
711 return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Query result verification failed");
714 vk::Move<vk::VkCommandBuffer> OcclusionQueryTestInstance::recordRender (vk::VkCommandPool cmdPool)
716 const vk::VkDevice device = m_context.getDevice();
717 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
719 const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
721 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
722 DE_NULL, // const void* pNext;
723 cmdPool, // VkCommandPool commandPool;
724 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
725 1u, // deUint32 bufferCount;
727 vk::Move<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
728 CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
730 vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
732 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
733 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_DepthImage->object(), vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
735 std::vector<vk::VkClearValue> renderPassClearValues(2);
736 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue));
738 const vk::VkRect2D renderArea =
741 { StateObjects::WIDTH, StateObjects::HEIGHT }
744 RenderPassBeginInfo renderPassBegin(*m_stateObjects->m_renderPass, *m_stateObjects->m_framebuffer, renderArea, renderPassClearValues);
746 vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL);
748 vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
750 vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_stateObjects->m_pipeline);
752 vk::VkBuffer vertexBuffer = m_stateObjects->m_vertexBuffer->object();
753 const vk::VkDeviceSize vertexBufferOffset = 0;
754 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
756 // Draw un-occluded geometry
757 vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_ALL, m_testVector.queryControlFlags);
758 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
759 vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_ALL);
761 // Partially occlude geometry
762 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL, 1, START_VERTEX_PARTIALLY_OCCLUDED, 0);
764 // Draw partially-occluded geometry
765 vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED, m_testVector.queryControlFlags);
766 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
767 vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED);
770 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_OCCLUDER_DRAWCALL, 1, START_VERTEX_OCCLUDER, 0);
772 // Draw occluded geometry
773 vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_OCCLUDED, m_testVector.queryControlFlags);
774 vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
775 vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_OCCLUDED);
777 if (m_testVector.queryWait != WAIT_QUEUE )
779 //For WAIT_QUEUE another cmdBuffer is issued with cmdCopyQueryPoolResults
780 if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
782 vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
786 vk.cmdEndRenderPass(*cmdBuffer);
788 transition2DImage(vk, *cmdBuffer, m_stateObjects->m_colorAttachmentImage->object(), vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
790 vk.endCommandBuffer(*cmdBuffer);
795 vk::Move<vk::VkCommandBuffer> OcclusionQueryTestInstance::recordCopyResults (vk::VkCommandPool cmdPool)
797 const vk::VkDevice device = m_context.getDevice();
798 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
800 const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
802 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
803 DE_NULL, // const void* pNext;
804 cmdPool, // VkCommandPool commandPool;
805 vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
806 1u, // deUint32 bufferCount;
808 vk::Move<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
809 const CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
811 vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
812 vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
813 vk.endCommandBuffer(*cmdBuffer);
818 void OcclusionQueryTestInstance::captureResults (deUint64* retResults, deUint64* retAvailAbility, bool allowNotReady)
821 const vk::VkDevice device = m_context.getDevice();
822 const vk::DeviceInterface& vk = m_context.getDeviceInterface();
823 std::vector<deUint8> resultsBuffer (static_cast<size_t>(m_testVector.queryResultsStride) * NUM_QUERIES_IN_POOL);
825 if (m_testVector.queryResultsMode == RESULTS_MODE_GET)
827 const vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, NUM_QUERIES_IN_POOL, resultsBuffer.size(), &resultsBuffer[0], m_testVector.queryResultsStride, m_queryResultFlags);
828 if (queryResult == vk::VK_NOT_READY && !allowNotReady)
830 TCU_FAIL("getQueryPoolResults returned VK_NOT_READY, but results should be already available.");
834 VK_CHECK(queryResult);
837 else if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
839 const vk::Allocation& allocation = m_queryPoolResultsBuffer->getBoundMemory();
840 const void* allocationData = allocation.getHostPtr();
842 vk::invalidateMappedMemoryRange(vk, device, allocation.getMemory(), allocation.getOffset(), resultsBuffer.size());
844 deMemcpy(&resultsBuffer[0], allocationData, resultsBuffer.size());
847 for (int queryNdx = 0; queryNdx < NUM_QUERIES_IN_POOL; queryNdx++)
849 const void* srcPtr = &resultsBuffer[queryNdx * static_cast<size_t>(m_testVector.queryResultsStride)];
850 if (m_testVector.queryResultSize == RESULT_SIZE_32_BIT)
852 const deUint32* srcPtrTyped = static_cast<const deUint32*>(srcPtr);
853 retResults[queryNdx] = *srcPtrTyped;
854 if (m_testVector.queryResultsAvailability)
856 retAvailAbility[queryNdx] = *(srcPtrTyped + 1);
859 else if (m_testVector.queryResultSize == RESULT_SIZE_64_BIT)
861 const deUint64* srcPtrTyped = static_cast<const deUint64*>(srcPtr);
862 retResults[queryNdx] = *srcPtrTyped;
864 if (m_testVector.queryResultsAvailability)
866 if (m_testVector.queryResultsAvailability)
868 retAvailAbility[queryNdx] = *(srcPtrTyped + 1);
874 TCU_FAIL("Wrong m_testVector.queryResultSize");
879 void OcclusionQueryTestInstance::logResults (const deUint64* results, const deUint64* availability)
881 tcu::TestLog& log = m_context.getTestContext().getLog();
883 for (int ndx = 0; ndx < NUM_QUERIES_IN_POOL; ++ndx)
885 if (!m_testVector.queryResultsAvailability)
887 log << tcu::TestLog::Message << "query[ slot == " << ndx << "] result == " << results[ndx] << tcu::TestLog::EndMessage;
891 log << tcu::TestLog::Message << "query[ slot == " << ndx << "] result == " << results[ndx] << ", availability == " << availability[ndx] << tcu::TestLog::EndMessage;
896 bool OcclusionQueryTestInstance::validateResults (const deUint64* results , const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology)
899 tcu::TestLog& log = m_context.getTestContext().getLog();
901 for (int queryNdx = 0; queryNdx < NUM_QUERIES_IN_POOL; ++queryNdx)
903 deUint64 expectedValueMin = 0;
904 deUint64 expectedValueMax = 0;
906 if (m_testVector.queryResultsAvailability && availability[queryNdx] == 0)
908 // query result was not available
909 if (!allowUnavailable)
911 log << tcu::TestLog::Message << "query results availability was 0 for index "
912 << queryNdx << ", expected any value greater than 0." << tcu::TestLog::EndMessage;
919 // query is available, so expect proper result values
920 if (primitiveTopology == vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
924 case QUERY_INDEX_CAPTURE_OCCLUDED:
925 expectedValueMin = 0;
926 expectedValueMax = 0;
928 case QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED:
929 expectedValueMin = 1;
930 expectedValueMax = 1;
932 case QUERY_INDEX_CAPTURE_ALL:
933 expectedValueMin = NUM_VERTICES_IN_DRAWCALL;
934 expectedValueMax = NUM_VERTICES_IN_DRAWCALL;
938 else if (primitiveTopology == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
942 case QUERY_INDEX_CAPTURE_OCCLUDED:
943 expectedValueMin = 0;
944 expectedValueMax = 0;
946 case QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED:
947 case QUERY_INDEX_CAPTURE_ALL:
949 const int primWidth = StateObjects::WIDTH / 2;
950 const int primHeight = StateObjects::HEIGHT / 2;
951 const int primArea = primWidth * primHeight / 2;
952 expectedValueMin = (int)(0.97f * primArea);
953 expectedValueMax = (int)(1.03f * primArea);
959 TCU_FAIL("Unsupported primitive topology");
963 if ((m_testVector.queryControlFlags & vk::VK_QUERY_CONTROL_PRECISE_BIT) || (expectedValueMin == 0 && expectedValueMax == 0))
965 // require precise value
966 if (results[queryNdx] < expectedValueMin || results[queryNdx] > expectedValueMax)
968 log << tcu::TestLog::Message << "wrong value of query for index "
969 << queryNdx << ", expected the value minimum of " << expectedValueMin << ", maximum of " << expectedValueMax << " got "
970 << results[queryNdx] << "." << tcu::TestLog::EndMessage;
976 // require imprecise value greater than 0
977 if (results[queryNdx] == 0)
979 log << tcu::TestLog::Message << "wrong value of query for index "
980 << queryNdx << ", expected any non-zero value, got "
981 << results[queryNdx] << "." << tcu::TestLog::EndMessage;
989 void OcclusionQueryTestInstance::logRenderTarget (void)
991 tcu::TestLog& log = m_context.getTestContext().getLog();
992 const vk::VkQueue queue = m_context.getUniversalQueue();
993 const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
994 tcu::ConstPixelBufferAccess resultImageAccess = m_stateObjects->m_colorAttachmentImage->readSurface(
995 queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
996 zeroOffset, StateObjects::HEIGHT, StateObjects::WIDTH, vk::VK_IMAGE_ASPECT_COLOR_BIT);
998 log << tcu::TestLog::Image("Result", "Result", resultImageAccess);
1001 template<class Instance>
1002 class QueryPoolOcclusionTest : public vkt::TestCase
1005 QueryPoolOcclusionTest (tcu::TestContext &context, const char *name, const char *description, const OcclusionQueryTestVector& testVector)
1006 : TestCase (context, name, description)
1007 , m_testVector (testVector)
1011 vkt::TestInstance* createInstance (vkt::Context& context) const
1013 return new Instance(context, m_testVector);
1016 void initPrograms(vk::SourceCollections& programCollection) const
1018 programCollection.glslSources.add("frag") << glu::FragmentSource("#version 400\n"
1019 "layout(location = 0) out vec4 out_FragColor;\n"
1022 " out_FragColor = vec4(0.07, 0.48, 0.75, 1.0);\n"
1025 programCollection.glslSources.add("vert") << glu::VertexSource("#version 430\n"
1026 "layout(location = 0) in vec4 in_Postion;\n"
1028 " gl_Position = in_Postion;\n"
1029 " gl_PointSize = 1.0;\n"
1033 OcclusionQueryTestVector m_testVector;
1044 QueryPoolOcclusionTests::QueryPoolOcclusionTests (tcu::TestContext &testCtx)
1045 : TestCaseGroup(testCtx, "occlusion_query", "Tests for occlusion queries")
1047 /* Left blank on purpose */
1050 QueryPoolOcclusionTests::~QueryPoolOcclusionTests (void)
1052 /* Left blank on purpose */
1055 void QueryPoolOcclusionTests::init (void)
1057 OcclusionQueryTestVector baseTestVector;
1058 baseTestVector.queryControlFlags = 0;
1059 baseTestVector.queryResultSize = RESULT_SIZE_64_BIT;
1060 baseTestVector.queryWait = WAIT_QUEUE;
1061 baseTestVector.queryResultsMode = RESULTS_MODE_GET;
1062 baseTestVector.queryResultsStride = sizeof(deUint64);
1063 baseTestVector.queryResultsAvailability = false;
1064 baseTestVector.primitiveRopology = vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
1068 OcclusionQueryTestVector testVector = baseTestVector;
1069 testVector.queryControlFlags = 0;
1070 addChild(new QueryPoolOcclusionTest<BasicOcclusionQueryTestInstance>(m_testCtx, "basic_conservative", "draw with conservative occlusion query", testVector));
1071 testVector.queryControlFlags = vk::VK_QUERY_CONTROL_PRECISE_BIT;
1072 addChild(new QueryPoolOcclusionTest<BasicOcclusionQueryTestInstance>(m_testCtx, "basic_precise", "draw with precise occlusion query", testVector));
1077 vk::VkQueryControlFlags controlFlags[] = { 0, vk::VK_QUERY_CONTROL_PRECISE_BIT };
1078 const char* controlFlagsStr[] = { "conservative", "precise" };
1080 for (int controlFlagIdx = 0; controlFlagIdx < DE_LENGTH_OF_ARRAY(controlFlags); ++controlFlagIdx)
1083 vk::VkPrimitiveTopology primitiveTopology[] = { vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST };
1084 const char* primitiveTopologyStr[] = { "points", "triangles" };
1085 for (int primitiveTopologyIdx = 0; primitiveTopologyIdx < DE_LENGTH_OF_ARRAY(primitiveTopology); ++primitiveTopologyIdx)
1088 OcclusionQueryResultSize resultSize[] = { RESULT_SIZE_32_BIT, RESULT_SIZE_64_BIT };
1089 const char* resultSizeStr[] = { "32", "64" };
1091 for (int resultSizeIdx = 0; resultSizeIdx < DE_LENGTH_OF_ARRAY(resultSize); ++resultSizeIdx)
1094 OcclusionQueryWait wait[] = { WAIT_QUEUE, WAIT_QUERY };
1095 const char* waitStr[] = { "queue", "query" };
1097 for (int waitIdx = 0; waitIdx < DE_LENGTH_OF_ARRAY(wait); ++waitIdx)
1099 OcclusionQueryResultsMode resultsMode[] = { RESULTS_MODE_GET, RESULTS_MODE_COPY };
1100 const char* resultsModeStr[] = { "get", "copy" };
1102 for (int resultsModeIdx = 0; resultsModeIdx < DE_LENGTH_OF_ARRAY(resultsMode); ++resultsModeIdx)
1105 bool testAvailability[] = { false, true };
1106 const char* testAvailabilityStr[] = { "without", "with"};
1108 for (int testAvailabilityIdx = 0; testAvailabilityIdx < DE_LENGTH_OF_ARRAY(testAvailability); ++testAvailabilityIdx)
1110 OcclusionQueryTestVector testVector = baseTestVector;
1111 testVector.queryControlFlags = controlFlags[controlFlagIdx];
1112 testVector.queryResultSize = resultSize[resultSizeIdx];
1113 testVector.queryWait = wait[waitIdx];
1114 testVector.queryResultsMode = resultsMode[resultsModeIdx];
1115 testVector.queryResultsStride = (testVector.queryResultSize == RESULT_SIZE_32_BIT ? sizeof(deUint32) : sizeof(deUint64));
1116 testVector.queryResultsAvailability = testAvailability[testAvailabilityIdx];
1117 testVector.primitiveRopology = primitiveTopology[primitiveTopologyIdx];
1119 if (testVector.queryResultsAvailability)
1121 testVector.queryResultsStride *= 2;
1124 std::ostringstream testName;
1125 std::ostringstream testDescr;
1127 testName << resultsModeStr[resultsModeIdx] << "_results"
1128 << "_" << controlFlagsStr[controlFlagIdx]
1129 << "_size_" << resultSizeStr[resultSizeIdx]
1130 << "_wait_" << waitStr[waitIdx]
1131 << "_" << testAvailabilityStr[testAvailabilityIdx] << "_availability"
1132 << "_draw_" << primitiveTopologyStr[primitiveTopologyIdx];
1134 testDescr << "draw occluded " << primitiveTopologyStr[primitiveTopologyIdx]
1135 << "with " << controlFlagsStr[controlFlagIdx] << ", "
1136 << resultsModeStr[resultsModeIdx] << " results "
1137 << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
1138 << resultSizeStr[resultSizeIdx] << "bit variables,"
1139 << "wait for results on" << waitStr[waitIdx];
1141 addChild(new QueryPoolOcclusionTest<OcclusionQueryTestInstance>(m_testCtx, testName.str().c_str(), testDescr.str().c_str(), testVector));
1149 // Test different strides
1151 OcclusionQueryResultsMode resultsMode[] = { RESULTS_MODE_GET, RESULTS_MODE_COPY };
1152 const char* resultsModeStr[] = { "get", "copy" };
1154 for (int resultsModeIdx = 0; resultsModeIdx < DE_LENGTH_OF_ARRAY(resultsMode); ++resultsModeIdx)
1156 OcclusionQueryResultSize resultSizes[] = { RESULT_SIZE_32_BIT, RESULT_SIZE_64_BIT };
1157 const char* resultSizeStr[] = { "32", "64" };
1159 bool testAvailability[] = { false, true };
1160 const char* testAvailabilityStr[] = { "without", "with" };
1162 for (int testAvailabilityIdx = 0; testAvailabilityIdx < DE_LENGTH_OF_ARRAY(testAvailability); ++testAvailabilityIdx)
1164 for (int resultSizeIdx = 0; resultSizeIdx < DE_LENGTH_OF_ARRAY(resultSizes); ++resultSizeIdx)
1166 const vk::VkDeviceSize resultSize = (resultSizes[resultSizeIdx] == RESULT_SIZE_32_BIT ? sizeof(deUint32) : sizeof(deUint64));
1168 // \todo [2015-12-18 scygan] Ensure only stride values aligned to resultSize are allowed. Otherwise test should be extended.
1169 const vk::VkDeviceSize strides[] =
1180 for (int strideIdx = 0; strideIdx < DE_LENGTH_OF_ARRAY(strides); strideIdx++)
1182 OcclusionQueryTestVector testVector = baseTestVector;
1183 testVector.queryResultsMode = resultsMode[resultsModeIdx];
1184 testVector.queryResultSize = resultSizes[resultSizeIdx];
1185 testVector.queryResultsAvailability = testAvailability[testAvailabilityIdx];
1186 testVector.queryResultsStride = strides[strideIdx];
1188 const vk::VkDeviceSize elementSize = (testVector.queryResultsAvailability ? resultSize * 2 : resultSize);
1190 if (elementSize > testVector.queryResultsStride)
1195 std::ostringstream testName;
1196 std::ostringstream testDescr;
1198 testName << resultsModeStr[resultsModeIdx]
1199 << "_results_size_" << resultSizeStr[resultSizeIdx]
1200 << "_stride_" << strides[strideIdx]
1201 << "_" << testAvailabilityStr[testAvailabilityIdx] << "_availability";
1203 testDescr << resultsModeStr[resultsModeIdx] << " results "
1204 << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
1205 << resultSizeStr[resultSizeIdx] << "bit variables, with stride" << strides[strideIdx];
1207 addChild(new QueryPoolOcclusionTest<OcclusionQueryTestInstance>(m_testCtx, testName.str().c_str(), testDescr.str().c_str(), testVector));