| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2021 The Khronos Group Inc. |
| * Copyright (c) 2021 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Fragment Operations Occlusion Query Tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktFragmentOperationsOcclusionQueryTests.hpp" |
| #include "vktFragmentOperationsMakeUtil.hpp" |
| #include "vktTestCaseUtil.hpp" |
| |
| #include "vkDefs.hpp" |
| #include "vkRef.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vkPlatform.hpp" |
| #include "vkPrograms.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkStrUtil.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "vkQueryUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkObjUtil.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuTextureUtil.hpp" |
| |
| #include "deUniquePtr.hpp" |
| #include "deStringUtil.hpp" |
| #include "deMath.h" |
| |
| #include <string> |
| |
| namespace vkt |
| { |
| namespace FragmentOperations |
| { |
| namespace |
| { |
| using namespace vk; |
| using de::UniquePtr; |
| |
| //! Basic 2D image. |
| inline VkImageCreateInfo makeImageCreateInfo (const tcu::IVec2& size, const VkFormat format, const VkImageUsageFlags usage) |
| { |
| const VkImageCreateInfo imageParams = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkImageCreateFlags)0, // VkImageCreateFlags flags; |
| VK_IMAGE_TYPE_2D, // VkImageType imageType; |
| format, // VkFormat format; |
| makeExtent3D(size.x(), size.y(), 1), // VkExtent3D extent; |
| 1u, // deUint32 mipLevels; |
| 1u, // deUint32 arrayLayers; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; |
| VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; |
| usage, // VkImageUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 0u, // deUint32 queueFamilyIndexCount; |
| DE_NULL, // const deUint32* pQueueFamilyIndices; |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; |
| }; |
| |
| return imageParams; |
| } |
| |
| Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk, |
| const VkDevice device, |
| const VkFormat colorFormat, |
| const bool useDepthStencilAttachment, |
| const VkFormat depthStencilFormat) |
| { |
| return makeRenderPass(vk, device, colorFormat, useDepthStencilAttachment ? depthStencilFormat : VK_FORMAT_UNDEFINED); |
| } |
| |
| Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface& vk, |
| const VkDevice device, |
| const VkPipelineLayout pipelineLayout, |
| const VkRenderPass renderPass, |
| const VkShaderModule vertexModule, |
| const VkShaderModule fragmentModule, |
| const tcu::IVec2& renderSize, |
| const bool enableScissorTest, |
| const bool enableDepthTest, |
| const bool enableStencilTest, |
| const bool enableStencilWrite) |
| { |
| const std::vector<VkViewport> viewports (1, makeViewport(renderSize)); |
| const std::vector<VkRect2D> scissors (1, enableScissorTest |
| ? makeRect2D(renderSize.x() / 4, renderSize.y() / 4, renderSize.x() / 4 * 2, renderSize.y() / 4 * 2) |
| : makeRect2D(renderSize)); |
| |
| const VkStencilOpState stencilOpState = makeStencilOpState(VK_STENCIL_OP_KEEP, // stencil fail |
| enableStencilWrite ? VK_STENCIL_OP_REPLACE : VK_STENCIL_OP_KEEP, // depth & stencil pass |
| VK_STENCIL_OP_KEEP, // depth only fail |
| enableStencilWrite ? VK_COMPARE_OP_ALWAYS : VK_COMPARE_OP_EQUAL, // compare op |
| 0xff, // compare mask |
| 0xff, // write mask |
| enableStencilWrite ? 0u : 1u); // reference |
| |
| VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| 0u, // VkPipelineDepthStencilStateCreateFlags flags |
| enableDepthTest ? VK_TRUE : VK_FALSE, // VkBool32 depthTestEnable |
| enableDepthTest ? VK_TRUE : VK_FALSE, // VkBool32 depthWriteEnable |
| VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp |
| VK_FALSE, // VkBool32 depthBoundsTestEnable |
| enableStencilTest ? VK_TRUE : VK_FALSE, // VkBool32 stencilTestEnable |
| enableStencilTest ? stencilOpState : VkStencilOpState{}, // VkStencilOpState front |
| enableStencilTest ? stencilOpState : VkStencilOpState{}, // VkStencilOpState back |
| 0.0f, // float minDepthBounds |
| 1.0f // float maxDepthBounds |
| }; |
| |
| return vk::makeGraphicsPipeline(vk, // const DeviceInterface& vk |
| device, // const VkDevice device |
| pipelineLayout, // const VkPipelineLayout pipelineLayout |
| vertexModule, // const VkShaderModule vertexShaderModule |
| DE_NULL, // const VkShaderModule tessellationControlModule |
| DE_NULL, // const VkShaderModule tessellationEvalModule |
| DE_NULL, // const VkShaderModule geometryShaderModule |
| fragmentModule, // const VkShaderModule fragmentShaderModule |
| renderPass, // const VkRenderPass renderPass |
| viewports, // const std::vector<VkViewport>& viewports |
| scissors, // const std::vector<VkRect2D>& scissors |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology |
| 0u, // const deUint32 subpass |
| 0u, // const deUint32 patchControlPoints |
| DE_NULL, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo |
| DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo |
| DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo |
| &depthStencilStateCreateInfo); // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo |
| } |
| |
| void commandClearDepthAttachment (const DeviceInterface& vk, |
| const VkCommandBuffer commandBuffer, |
| const VkOffset2D& offset, |
| const VkExtent2D& extent, |
| const deUint32 clearValue) |
| { |
| const VkClearAttachment depthAttachment = |
| { |
| VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask; |
| 0u, // uint32_t colorAttachment; |
| makeClearValueDepthStencil(0.0f, clearValue), // VkClearValue clearValue; |
| }; |
| |
| const VkClearRect rect = |
| { |
| { offset, extent }, // VkRect2D rect; |
| 0u, // uint32_t baseArrayLayer; |
| 1u, // uint32_t layerCount; |
| }; |
| |
| vk.cmdClearAttachments(commandBuffer, 1u, &depthAttachment, 1u, &rect); |
| } |
| |
| void commandClearStencilAttachment (const DeviceInterface& vk, |
| const VkCommandBuffer commandBuffer, |
| const VkOffset2D& offset, |
| const VkExtent2D& extent, |
| const deUint32 clearValue) |
| { |
| const VkClearAttachment stencilAttachment = |
| { |
| VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask; |
| 0u, // uint32_t colorAttachment; |
| makeClearValueDepthStencil(0.0f, clearValue), // VkClearValue clearValue; |
| }; |
| |
| const VkClearRect rect = |
| { |
| { offset, extent }, // VkRect2D rect; |
| 0u, // uint32_t baseArrayLayer; |
| 1u, // uint32_t layerCount; |
| }; |
| |
| vk.cmdClearAttachments(commandBuffer, 1u, &stencilAttachment, 1u, &rect); |
| } |
| |
| VkImageAspectFlags getImageAspectFlags (const VkFormat format) |
| { |
| const tcu::TextureFormat tcuFormat = mapVkFormat(format); |
| |
| if (tcuFormat.order == tcu::TextureFormat::DS) return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; |
| else if (tcuFormat.order == tcu::TextureFormat::D) return VK_IMAGE_ASPECT_DEPTH_BIT; |
| else if (tcuFormat.order == tcu::TextureFormat::S) return VK_IMAGE_ASPECT_STENCIL_BIT; |
| |
| DE_ASSERT(false); |
| return 0u; |
| } |
| |
| bool isSupportedDepthStencilFormat (const InstanceInterface& instanceInterface, const VkPhysicalDevice device, const VkFormat format) |
| { |
| VkFormatProperties formatProps; |
| instanceInterface.getPhysicalDeviceFormatProperties(device, format, &formatProps); |
| return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0; |
| } |
| |
| VkFormat pickSupportedDepthStencilFormat (const InstanceInterface& instanceInterface, |
| const VkPhysicalDevice device) |
| { |
| static const VkFormat dsFormats[] = |
| { |
| VK_FORMAT_D16_UNORM_S8_UINT, |
| VK_FORMAT_D24_UNORM_S8_UINT, |
| VK_FORMAT_D32_SFLOAT_S8_UINT, |
| }; |
| |
| for (deUint32 i = 0; i < DE_LENGTH_OF_ARRAY(dsFormats); ++i) |
| if (isSupportedDepthStencilFormat(instanceInterface, device, dsFormats[i])) |
| return dsFormats[i]; |
| |
| return VK_FORMAT_UNDEFINED; |
| } |
| |
| enum Flags |
| { |
| TEST_NO_FLAGS = 0, |
| TEST_SCISSOR = 1u << 0, |
| TEST_DEPTH_WRITE = 1u << 1, |
| TEST_DEPTH_CLEAR = 1u << 2, |
| TEST_STENCIL_WRITE = 1u << 3, |
| TEST_STENCIL_CLEAR = 1u << 4, |
| TEST_ALL = 1u << 5, |
| TEST_PRECISE_BIT = 1u << 6 |
| }; |
| |
| class OcclusionQueryTestInstance : public TestInstance |
| { |
| public: |
| OcclusionQueryTestInstance (Context& context, |
| const tcu::IVec2 renderSize, |
| const bool preciseBitEnabled, |
| const bool scissorTestEnabled, |
| const bool depthTestEnabled, |
| const bool stencilTestEnabled, |
| const bool depthWriteEnabled, |
| const bool stencilWriteEnabled); |
| |
| tcu::TestStatus iterate (void); |
| |
| private: |
| const tcu::IVec2 m_renderSize; |
| const bool m_preciseBitEnabled; |
| const bool m_scissorTestEnabled; |
| const bool m_depthClearTestEnabled; |
| const bool m_stencilClearTestEnabled; |
| const bool m_depthWriteTestEnabled; |
| const bool m_stencilWriteTestEnabled; |
| }; |
| |
| OcclusionQueryTestInstance::OcclusionQueryTestInstance (Context& context, |
| const tcu::IVec2 renderSize, |
| const bool preciseBitEnabled, |
| const bool scissorTestEnabled, |
| const bool depthClearTestEnabled, |
| const bool stencilClearTestEnabled, |
| const bool depthWriteTestEnabled, |
| const bool stencilWriteTestEnabled) |
| : TestInstance (context) |
| , m_renderSize (renderSize) |
| , m_preciseBitEnabled (preciseBitEnabled) |
| , m_scissorTestEnabled (scissorTestEnabled) |
| , m_depthClearTestEnabled (depthClearTestEnabled) |
| , m_stencilClearTestEnabled (stencilClearTestEnabled) |
| , m_depthWriteTestEnabled (depthWriteTestEnabled) |
| , m_stencilWriteTestEnabled (stencilWriteTestEnabled) |
| { |
| } |
| |
| tcu::TestStatus OcclusionQueryTestInstance::iterate (void) |
| { |
| const DeviceInterface& vk = m_context.getDeviceInterface(); |
| const InstanceInterface& vki = m_context.getInstanceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| const VkPhysicalDevice physDevice = m_context.getPhysicalDevice(); |
| const VkQueue queue = m_context.getUniversalQueue(); |
| const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| VkQueryPool queryPool; |
| const deUint32 queryCount = 1u; |
| std::vector<VkDeviceSize> sampleCounts (queryCount); |
| |
| // Create a query pool for storing the occlusion query result |
| { |
| VkQueryPoolCreateInfo queryPoolInfo |
| { |
| VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags; |
| VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType; |
| queryCount, // uint32_t queryCount; |
| 0u, // VkQueryPipelineStatisticFlags pipelineStatistics; |
| }; |
| VK_CHECK(vk.createQueryPool(device, &queryPoolInfo, NULL, &queryPool)); |
| } |
| |
| // Color attachment |
| const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| const VkImageSubresourceRange colorSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); |
| const Unique<VkImage> colorImage (makeImage(vk, device, makeImageCreateInfo(m_renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT))); |
| const UniquePtr<Allocation> colorImageAlloc (bindImage(vk, device, allocator, *colorImage, MemoryRequirement::Any)); |
| const Unique<VkImageView> colorImageView (makeImageView(vk, device, *colorImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorSubresourceRange)); |
| |
| std::vector<VkImageView> attachmentImages = { *colorImageView }; |
| |
| bool depthTestsEnabled = (m_depthClearTestEnabled || m_depthWriteTestEnabled); |
| bool stencilTestsEnabled = (m_stencilClearTestEnabled || m_stencilWriteTestEnabled); |
| |
| const VkFormat testFormat = (depthTestsEnabled && stencilTestsEnabled |
| ? pickSupportedDepthStencilFormat(vki, physDevice) |
| : !depthTestsEnabled && stencilTestsEnabled |
| ? VK_FORMAT_S8_UINT |
| : VK_FORMAT_D16_UNORM); |
| |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Using depth/stencil format " << getFormatName(testFormat) << tcu::TestLog::EndMessage; |
| |
| const VkImageSubresourceRange testSubresourceRange = makeImageSubresourceRange(getImageAspectFlags(testFormat), 0u, 1u, 0u, 1u); |
| const Unique<VkImage> testImage(makeImage(vk, device, makeImageCreateInfo(m_renderSize, testFormat, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))); |
| const UniquePtr<Allocation> testImageAlloc(bindImage(vk, device, allocator, *testImage, MemoryRequirement::Any)); |
| const Unique<VkImageView> testImageView(makeImageView(vk, device, *testImage, VK_IMAGE_VIEW_TYPE_2D, testFormat, testSubresourceRange)); |
| |
| if (depthTestsEnabled || stencilTestsEnabled) |
| attachmentImages.push_back(*testImageView); |
| |
| const deUint32 numUsedAttachmentImages = deUint32(attachmentImages.size()); |
| |
| // Depth occluder vertex buffer |
| const deUint32 numDepthOccVertices = 6; |
| const VkDeviceSize dOccVertBuffSizeBytes = 256; |
| const Unique<VkBuffer> dOccluderVertexBuffer (makeBuffer(vk, device, dOccVertBuffSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)); |
| const UniquePtr<Allocation> dOccVertexBufferAlloc (bindBuffer(vk, device, allocator, *dOccluderVertexBuffer, MemoryRequirement::HostVisible)); |
| |
| { |
| tcu::Vec4* const pVertices = reinterpret_cast<tcu::Vec4*>(dOccVertexBufferAlloc->getHostPtr()); |
| |
| pVertices[0] = tcu::Vec4(-0.25f, -0.50f , 0.0f, 1.0f); // Top Right |
| pVertices[1] = tcu::Vec4(-0.50f, -0.50f , 0.0f, 1.0f); // Top Left |
| pVertices[2] = tcu::Vec4(-0.25f, -0.25f, 0.0f, 1.0f); // Bottom Right |
| pVertices[3] = tcu::Vec4(-0.50f, -0.25f, 0.0f, 1.0f); // Bottom Left |
| pVertices[4] = tcu::Vec4(-0.25f, -0.25f, 0.0f, 1.0f); // Bottom Right |
| pVertices[5] = tcu::Vec4(-0.50f, -0.50f, 0.0f, 1.0f); // Top Left |
| |
| flushAlloc(vk, device, *dOccVertexBufferAlloc); |
| } |
| |
| // Stencil occluder vertex buffer |
| const deUint32 numStencilOccVertices = 6; |
| const VkDeviceSize sOccVertBuffSizeBytes = 256; |
| const Unique<VkBuffer> sOccluderVertexBuffer (makeBuffer(vk, device, sOccVertBuffSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)); |
| const UniquePtr<Allocation> sOccVertexBufferAlloc (bindBuffer(vk, device, allocator, *sOccluderVertexBuffer, MemoryRequirement::HostVisible)); |
| |
| { |
| tcu::Vec4* const pVertices = reinterpret_cast<tcu::Vec4*>(sOccVertexBufferAlloc->getHostPtr()); |
| |
| pVertices[0] = tcu::Vec4(-0.25f, -0.25f, 0.0f, 1.0f); // Top Right |
| pVertices[1] = tcu::Vec4(-0.50f, -0.25f, 0.0f, 1.0f); // Top Left |
| pVertices[2] = tcu::Vec4(-0.25f, 0.00f, 0.0f, 1.0f); // Bottom Right |
| pVertices[3] = tcu::Vec4(-0.50f, 0.00f, 0.0f, 1.0f); // Bottom Left |
| pVertices[4] = tcu::Vec4(-0.25f, 0.00f, 0.0f, 1.0f); // Bottom Right |
| pVertices[5] = tcu::Vec4(-0.50f, -0.25f, 0.0f, 1.0f); // Top Left |
| |
| flushAlloc(vk, device, *sOccVertexBufferAlloc); |
| } |
| |
| // Main vertex buffer |
| const deUint32 numVertices = 6; |
| const VkDeviceSize vertexBufferSizeBytes = 256; |
| const Unique<VkBuffer> vertexBuffer (makeBuffer(vk, device, vertexBufferSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)); |
| const UniquePtr<Allocation> vertexBufferAlloc (bindBuffer(vk, device, allocator, *vertexBuffer, MemoryRequirement::HostVisible)); |
| |
| { |
| tcu::Vec4* const pVertices = reinterpret_cast<tcu::Vec4*>(vertexBufferAlloc->getHostPtr()); |
| |
| pVertices[0] = tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f); |
| pVertices[1] = tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f); |
| pVertices[2] = tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f); |
| pVertices[3] = tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f); |
| pVertices[4] = tcu::Vec4( 1.0f, 1.0f, 1.0f, 1.0f); |
| pVertices[5] = tcu::Vec4( 1.0f, -1.0f, 1.0f, 1.0f); |
| |
| flushAlloc(vk, device, *vertexBufferAlloc); |
| } |
| |
| // Result buffer |
| const VkDeviceSize resultBufferSizeBytes = sizeof(deUint32); |
| const Unique<VkBuffer> resultBuffer (makeBuffer(vk, device, resultBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)); |
| const UniquePtr<Allocation> resultBufferAlloc (bindBuffer(vk, device, allocator, *resultBuffer, MemoryRequirement::HostVisible)); |
| |
| { |
| deUint32* const pData = static_cast<deUint32*>(resultBufferAlloc->getHostPtr()); |
| |
| *pData = 0; |
| flushAlloc(vk, device, *resultBufferAlloc); |
| } |
| |
| // Render result buffer (to retrieve color attachment contents) |
| const VkDeviceSize colorBufferSizeBytes = tcu::getPixelSize(mapVkFormat(colorFormat)) * m_renderSize.x() * m_renderSize.y(); |
| const Unique<VkBuffer> colorBuffer (makeBuffer(vk, device, colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT)); |
| const UniquePtr<Allocation> colorBufferAlloc (bindBuffer(vk, device, allocator, *colorBuffer, MemoryRequirement::HostVisible)); |
| |
| // Pipeline |
| const Unique<VkShaderModule> vertexModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0u)); |
| const Unique<VkShaderModule> fragmentModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0u)); |
| const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device, colorFormat, (depthTestsEnabled || stencilTestsEnabled), testFormat)); |
| const Unique<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, numUsedAttachmentImages, attachmentImages.data(), m_renderSize.x(), m_renderSize.y())); |
| const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, DE_NULL)); |
| const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertexModule, *fragmentModule, m_renderSize, |
| m_scissorTestEnabled, depthTestsEnabled, stencilTestsEnabled, false)); |
| |
| const Unique<VkPipeline> pipelineStencilWrite (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertexModule, *fragmentModule, m_renderSize, |
| m_scissorTestEnabled, false, stencilTestsEnabled, true)); |
| |
| // Command buffer |
| const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex)); |
| const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); |
| |
| { |
| const tcu::Vec4 clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); |
| const float clearDepth = 0.5f; |
| const deUint32 clearStencil = 1u; |
| const VkDeviceSize vertexBufferOffset = 0ull; |
| |
| const VkRect2D renderArea = |
| { |
| makeOffset2D(0, 0), |
| makeExtent2D(m_renderSize.x(), m_renderSize.y()), |
| }; |
| |
| beginCommandBuffer(vk, *cmdBuffer); |
| |
| vk.cmdResetQueryPool(*cmdBuffer, queryPool, 0, queryCount); |
| |
| // Will clear the attachments with specified depth and stencil values. |
| beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor, clearDepth, clearStencil); |
| |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); |
| |
| // Mask half of the attachment image with value that will pass the stencil test. |
| if (m_depthClearTestEnabled) |
| commandClearDepthAttachment(vk, *cmdBuffer, makeOffset2D(0, m_renderSize.y() / 2), makeExtent2D(m_renderSize.x(), m_renderSize.y() / 2), 1u); |
| |
| // Mask half of the attachment image with value that will pass the stencil test. |
| if (m_stencilClearTestEnabled) |
| commandClearStencilAttachment(vk, *cmdBuffer, makeOffset2D(m_renderSize.x() / 2, 0), makeExtent2D(m_renderSize.x() / 2, m_renderSize.y()), 0u); |
| |
| if (m_depthWriteTestEnabled) |
| { |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &dOccluderVertexBuffer.get(), &vertexBufferOffset); |
| vk.cmdDraw(*cmdBuffer, numDepthOccVertices, 1u, 0u, 0u); |
| } |
| |
| if (m_stencilWriteTestEnabled) |
| { |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineStencilWrite); |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &sOccluderVertexBuffer.get(), &vertexBufferOffset); |
| vk.cmdDraw(*cmdBuffer, numStencilOccVertices, 1u, 0u, 0u); |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); |
| } |
| |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset); |
| |
| if (m_preciseBitEnabled) |
| { |
| vk.cmdBeginQuery(cmdBuffer.get(), queryPool, 0, VK_QUERY_CONTROL_PRECISE_BIT); |
| } |
| else |
| { |
| vk.cmdBeginQuery(cmdBuffer.get(), queryPool, 0, DE_NULL); |
| } |
| |
| vk.cmdDraw(*cmdBuffer, numVertices, 1u, 0u, 0u); |
| vk.cmdEndQuery(cmdBuffer.get(), queryPool, 0); |
| |
| endRenderPass(vk, *cmdBuffer); |
| |
| copyImageToBuffer(vk, *cmdBuffer, *colorImage, *colorBuffer, m_renderSize, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT); |
| |
| endCommandBuffer(vk, *cmdBuffer); |
| submitCommandsAndWait(vk, device, queue, *cmdBuffer); |
| } |
| |
| // Check results |
| { |
| deUint64 expResult = 0; |
| |
| if (m_preciseBitEnabled) |
| { |
| const deUint64 imageSize = m_scissorTestEnabled ? deUint64(m_renderSize.x()) * deUint64(m_renderSize.y()) / 4u |
| : deUint64(m_renderSize.x()) * deUint64(m_renderSize.y()); |
| |
| const deUint64 renderHeight = m_scissorTestEnabled ? deUint64(m_renderSize.y() / 2u) |
| : deUint64(m_renderSize.y()); |
| |
| const deUint64 occluderWriteSize = deUint64(m_renderSize.x()) * deUint64(m_renderSize.y()) / 64u; |
| |
| if (m_depthClearTestEnabled || m_stencilClearTestEnabled) |
| { |
| if (m_depthClearTestEnabled && m_stencilClearTestEnabled) |
| { |
| expResult = imageSize / 4; |
| } |
| |
| if (!m_depthClearTestEnabled && m_stencilClearTestEnabled) |
| { |
| expResult = imageSize / 2; |
| } |
| |
| if (m_depthClearTestEnabled && !m_stencilClearTestEnabled) |
| { |
| expResult = imageSize / 2 - imageSize / 8 - renderHeight / 4; |
| } |
| } |
| else if (m_depthWriteTestEnabled) |
| { |
| expResult = imageSize / 2 - renderHeight / 2; |
| } |
| else |
| { |
| expResult = imageSize; |
| } |
| |
| if (m_depthWriteTestEnabled) |
| { |
| expResult -= occluderWriteSize; |
| |
| if (m_stencilClearTestEnabled && !m_depthClearTestEnabled) |
| { |
| expResult -= (imageSize / 8 + renderHeight / 4); |
| } |
| } |
| |
| if (m_stencilWriteTestEnabled) |
| { |
| expResult -= occluderWriteSize; |
| } |
| } |
| |
| VK_CHECK(vk.getQueryPoolResults(device, queryPool, 0u, queryCount, queryCount * sizeof(VkDeviceSize), sampleCounts.data(), sizeof(VkDeviceSize), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT)); |
| |
| // Log test results |
| { |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| log << tcu::TestLog::Message << "Passed Samples : " << de::toString(sampleCounts[0]) << " / " << expResult << tcu::TestLog::EndMessage; |
| } |
| |
| vk.destroyQueryPool(device, queryPool, nullptr); |
| |
| if ((m_preciseBitEnabled && sampleCounts[0] == expResult) || (!m_preciseBitEnabled && sampleCounts[0] > 0)) |
| { |
| return tcu::TestStatus::pass("Success"); |
| } |
| else |
| { |
| |
| invalidateAlloc(vk, device, *colorBufferAlloc); |
| |
| const tcu::ConstPixelBufferAccess imagePixelAccess (mapVkFormat(colorFormat), m_renderSize.x(), m_renderSize.y(), 1, colorBufferAlloc->getHostPtr()); |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| |
| log << tcu::TestLog::Image("color0", "Rendered image", imagePixelAccess); |
| |
| return tcu::TestStatus::fail("Failure"); |
| } |
| } |
| } |
| |
| class OcclusionQueryTest : public TestCase |
| { |
| public: |
| OcclusionQueryTest (tcu::TestContext& testCtx, |
| const std::string name, |
| const deUint32 flags, |
| const int renderWidth, |
| const int renderHeight); |
| |
| void initPrograms (SourceCollections& programCollection) const; |
| TestInstance* createInstance (Context& context) const; |
| virtual void checkSupport (Context& context) const; |
| |
| private: |
| const bool m_preciseBitEnabled; |
| const bool m_scissorTestEnabled; |
| const bool m_depthClearTestEnabled; |
| const bool m_stencilClearTestEnabled; |
| const bool m_depthWriteTestEnabled; |
| const bool m_stencilWriteTestEnabled; |
| const int m_renderWidth; |
| const int m_renderHeight; |
| }; |
| |
| OcclusionQueryTest::OcclusionQueryTest (tcu::TestContext& testCtx, const std::string name, const deUint32 flags, const int renderWidth, const int renderHeight) |
| : TestCase (testCtx, name, "") |
| , m_preciseBitEnabled (flags & TEST_PRECISE_BIT) |
| , m_scissorTestEnabled (flags & TEST_SCISSOR) |
| , m_depthClearTestEnabled (flags & TEST_DEPTH_CLEAR || flags & TEST_ALL) |
| , m_stencilClearTestEnabled (flags & TEST_STENCIL_CLEAR || flags & TEST_ALL) |
| , m_depthWriteTestEnabled (flags & TEST_DEPTH_WRITE || flags & TEST_ALL) |
| , m_stencilWriteTestEnabled (flags & TEST_STENCIL_WRITE || flags & TEST_ALL) |
| , m_renderWidth (renderWidth) |
| , m_renderHeight (renderHeight) |
| { |
| } |
| |
| void OcclusionQueryTest::initPrograms (SourceCollections& programCollection) const |
| { |
| // Vertex |
| { |
| std::ostringstream src; |
| |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" |
| << "\n" |
| << "layout(location = 0) in highp vec4 position;\n" |
| << "\n" |
| << "out gl_PerVertex\n" |
| << "{\n" |
| << " vec4 gl_Position;\n" |
| << "};\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " gl_Position = position;\n" |
| << "}\n"; |
| |
| programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); |
| } |
| |
| // Fragment |
| { |
| std::ostringstream src; |
| |
| src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" |
| << "\n" |
| << "layout(location = 0) out highp vec4 fragColor;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " fragColor = vec4(gl_FragCoord.x / " << m_renderWidth << ", gl_FragCoord.y / " << m_renderHeight << ", 0.0, 1.0); \n" |
| << "}\n"; |
| |
| programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); |
| } |
| } |
| |
| TestInstance* OcclusionQueryTest::createInstance (Context& context) const |
| { |
| return new OcclusionQueryTestInstance (context, tcu::IVec2(m_renderWidth, m_renderHeight), |
| m_preciseBitEnabled, m_scissorTestEnabled, |
| m_depthClearTestEnabled, m_stencilClearTestEnabled, |
| m_depthWriteTestEnabled, m_stencilWriteTestEnabled); |
| } |
| |
| void OcclusionQueryTest::checkSupport (Context& context) const |
| { |
| const InstanceInterface& vki = context.getInstanceInterface(); |
| const VkPhysicalDevice physDevice = context.getPhysicalDevice(); |
| VkImageFormatProperties formatProperties; |
| |
| bool depthTestsEnabled = (m_depthClearTestEnabled || m_depthWriteTestEnabled); |
| bool stencilTestsEnabled = (m_stencilClearTestEnabled || m_stencilWriteTestEnabled); |
| |
| const VkFormat testFormat = (stencilTestsEnabled && depthTestsEnabled |
| ? pickSupportedDepthStencilFormat(vki, physDevice) |
| : stencilTestsEnabled |
| ? VK_FORMAT_S8_UINT |
| : VK_FORMAT_D16_UNORM); |
| |
| if (m_preciseBitEnabled) |
| { |
| vk::VkQueryControlFlags queryControlFlags = { VK_QUERY_CONTROL_PRECISE_BIT }; |
| |
| if (queryControlFlags && vk::VK_QUERY_CONTROL_PRECISE_BIT != context.getDeviceFeatures().occlusionQueryPrecise) |
| TCU_THROW(NotSupportedError, "Precise occlusion queries are not supported"); |
| } |
| |
| vki.getPhysicalDeviceImageFormatProperties(physDevice, testFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0u, &formatProperties); |
| if (formatProperties.sampleCounts == 0 || testFormat == VK_FORMAT_UNDEFINED) |
| TCU_THROW(NotSupportedError, de::toString(testFormat) + " not supported"); |
| } |
| |
| } // anonymous ns |
| |
| tcu::TestCaseGroup* createOcclusionQueryTests(tcu::TestContext& testCtx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "occlusion_query", "occlusion query test cases")); |
| |
| { |
| static const struct |
| { |
| std::string caseName; |
| deUint32 flags; |
| } cases[] = |
| { |
| { "_test_scissors_clear_color", TEST_SCISSOR }, |
| { "_test_scissors_depth_clear", TEST_SCISSOR | TEST_DEPTH_CLEAR }, |
| { "_test_scissors_depth_write", TEST_SCISSOR | TEST_DEPTH_WRITE }, |
| { "_test_scissors_depth_clear_depth_write", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE }, |
| { "_test_scissors_stencil_clear", TEST_SCISSOR | TEST_STENCIL_CLEAR }, |
| { "_test_scissors_stencil_write", TEST_SCISSOR | TEST_STENCIL_WRITE }, |
| { "_test_scissors_stencil_clear_stencil_write", TEST_SCISSOR | TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_scissors_depth_clear_stencil_clear", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_STENCIL_CLEAR }, |
| { "_test_scissors_depth_write_stencil_clear", TEST_SCISSOR | TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR }, |
| { "_test_scissors_depth_clear_stencil_write", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_scissors_depth_write_stencil_write", TEST_SCISSOR | TEST_DEPTH_WRITE | TEST_STENCIL_WRITE }, |
| { "_test_scissors_depth_clear_stencil_clear_depth_write", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR }, |
| { "_test_scissors_depth_clear_stencil_clear_stencil_write", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_scissors_depth_clear_depth_write_stencil_write", TEST_SCISSOR | TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE | TEST_STENCIL_WRITE }, |
| { "_test_scissors_depth_write_stencil_clear_stencil_write", TEST_SCISSOR | TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_scissors_test_all", TEST_SCISSOR | TEST_ALL }, |
| { "_test_clear_color", TEST_NO_FLAGS }, |
| { "_test_depth_clear", TEST_DEPTH_CLEAR }, |
| { "_test_depth_write", TEST_DEPTH_WRITE }, |
| { "_test_depth_clear_depth_write", TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE }, |
| { "_test_stencil_clear", TEST_STENCIL_CLEAR }, |
| { "_test_stencil_write", TEST_STENCIL_WRITE }, |
| { "_test_stencil_clear_stencil_write", TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_depth_clear_stencil_clear", TEST_DEPTH_CLEAR | TEST_STENCIL_CLEAR }, |
| { "_test_depth_write_stencil_clear", TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR }, |
| { "_test_depth_clear_stencil_write", TEST_DEPTH_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_depth_write_stencil_write", TEST_DEPTH_WRITE | TEST_STENCIL_WRITE }, |
| { "_test_depth_clear_stencil_clear_depth_write", TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR }, |
| { "_test_depth_clear_stencil_clear_stencil_write", TEST_DEPTH_CLEAR | TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_depth_clear_depth_write_stencil_write", TEST_DEPTH_CLEAR | TEST_DEPTH_WRITE | TEST_STENCIL_WRITE }, |
| { "_test_depth_write_stencil_clear_stencil_write", TEST_DEPTH_WRITE | TEST_STENCIL_CLEAR | TEST_STENCIL_WRITE }, |
| { "_test_test_all", TEST_ALL } |
| }; |
| |
| // Conservative tests |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(cases); ++i) |
| testGroup->addChild(new OcclusionQueryTest(testCtx, "conservative" + cases[i].caseName, cases[i].flags, 32, 32)); |
| |
| // Precise tests |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(cases); ++i) |
| testGroup->addChild(new OcclusionQueryTest(testCtx, "precise" + cases[i].caseName, cases[i].flags | TEST_PRECISE_BIT, 32, 32)); |
| } |
| |
| return testGroup.release(); |
| } |
| |
| } // FragmentOperations |
| } // vkt |
