From 8cb3022404aeaf04fa05b8f8655aa3f50e490e5a Mon Sep 17 00:00:00 2001 From: Boris Zanin Date: Thu, 23 Jan 2020 16:28:01 +0100 Subject: [PATCH] Ray tracing watertightness tests Tests split area onto a set of trinagles and make sure that all rays hit some triangle. Add tests: * dEQP-VK.ray_tracing.watertightness.* Components: Vulkan VK-GL-CTS issue: 2135 Change-Id: Idd755ffe5f4700222b724e5459287f996bb19862 --- AndroidGen.mk | 1 + android/cts/master/vk-master-2020-03-01.txt | 80 +++ android/cts/master/vk-master.txt | 80 +++ .../modules/vulkan/ray_tracing/CMakeLists.txt | 2 + .../vulkan/ray_tracing/vktRayTracingTests.cpp | 2 + .../vktRayTracingWatertightnessTests.cpp | 575 +++++++++++++++++++++ .../vktRayTracingWatertightnessTests.hpp | 39 ++ external/vulkancts/mustpass/master/vk-default.txt | 80 +++ 8 files changed, 859 insertions(+) create mode 100644 external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.cpp create mode 100644 external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.hpp diff --git a/AndroidGen.mk b/AndroidGen.mk index 734c906..db2bd37 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -270,6 +270,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp \ external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTraceRaysIndirectTests.cpp \ external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTraversalControlTests.cpp \ + external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassDepthStencilResolveTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassFragmentDensityMapTests.cpp \ external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultipleSubpassesMultipleCommandBuffersTests.cpp \ diff --git a/android/cts/master/vk-master-2020-03-01.txt b/android/cts/master/vk-master-2020-03-01.txt index d0a62ba..6a3b1b3 100644 --- a/android/cts/master/vk-master-2020-03-01.txt +++ b/android/cts/master/vk-master-2020-03-01.txt @@ -199633,3 +199633,83 @@ dEQP-VK.ray_tracing.acceleration_structures.operations.serialization.gpu_built.b dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_build_scratch dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_update_scratch dEQP-VK.ray_tracing.indirect.build_structure +dEQP-VK.ray_tracing.watertightness.0.4 +dEQP-VK.ray_tracing.watertightness.0.16 +dEQP-VK.ray_tracing.watertightness.0.64 +dEQP-VK.ray_tracing.watertightness.0.256 +dEQP-VK.ray_tracing.watertightness.0.1024 +dEQP-VK.ray_tracing.watertightness.0.4096 +dEQP-VK.ray_tracing.watertightness.0.16384 +dEQP-VK.ray_tracing.watertightness.0.65536 +dEQP-VK.ray_tracing.watertightness.1.4 +dEQP-VK.ray_tracing.watertightness.1.16 +dEQP-VK.ray_tracing.watertightness.1.64 +dEQP-VK.ray_tracing.watertightness.1.256 +dEQP-VK.ray_tracing.watertightness.1.1024 +dEQP-VK.ray_tracing.watertightness.1.4096 +dEQP-VK.ray_tracing.watertightness.1.16384 +dEQP-VK.ray_tracing.watertightness.1.65536 +dEQP-VK.ray_tracing.watertightness.2.4 +dEQP-VK.ray_tracing.watertightness.2.16 +dEQP-VK.ray_tracing.watertightness.2.64 +dEQP-VK.ray_tracing.watertightness.2.256 +dEQP-VK.ray_tracing.watertightness.2.1024 +dEQP-VK.ray_tracing.watertightness.2.4096 +dEQP-VK.ray_tracing.watertightness.2.16384 +dEQP-VK.ray_tracing.watertightness.2.65536 +dEQP-VK.ray_tracing.watertightness.3.4 +dEQP-VK.ray_tracing.watertightness.3.16 +dEQP-VK.ray_tracing.watertightness.3.64 +dEQP-VK.ray_tracing.watertightness.3.256 +dEQP-VK.ray_tracing.watertightness.3.1024 +dEQP-VK.ray_tracing.watertightness.3.4096 +dEQP-VK.ray_tracing.watertightness.3.16384 +dEQP-VK.ray_tracing.watertightness.3.65536 +dEQP-VK.ray_tracing.watertightness.4.4 +dEQP-VK.ray_tracing.watertightness.4.16 +dEQP-VK.ray_tracing.watertightness.4.64 +dEQP-VK.ray_tracing.watertightness.4.256 +dEQP-VK.ray_tracing.watertightness.4.1024 +dEQP-VK.ray_tracing.watertightness.4.4096 +dEQP-VK.ray_tracing.watertightness.4.16384 +dEQP-VK.ray_tracing.watertightness.4.65536 +dEQP-VK.ray_tracing.watertightness.5.4 +dEQP-VK.ray_tracing.watertightness.5.16 +dEQP-VK.ray_tracing.watertightness.5.64 +dEQP-VK.ray_tracing.watertightness.5.256 +dEQP-VK.ray_tracing.watertightness.5.1024 +dEQP-VK.ray_tracing.watertightness.5.4096 +dEQP-VK.ray_tracing.watertightness.5.16384 +dEQP-VK.ray_tracing.watertightness.5.65536 +dEQP-VK.ray_tracing.watertightness.6.4 +dEQP-VK.ray_tracing.watertightness.6.16 +dEQP-VK.ray_tracing.watertightness.6.64 +dEQP-VK.ray_tracing.watertightness.6.256 +dEQP-VK.ray_tracing.watertightness.6.1024 +dEQP-VK.ray_tracing.watertightness.6.4096 +dEQP-VK.ray_tracing.watertightness.6.16384 +dEQP-VK.ray_tracing.watertightness.6.65536 +dEQP-VK.ray_tracing.watertightness.7.4 +dEQP-VK.ray_tracing.watertightness.7.16 +dEQP-VK.ray_tracing.watertightness.7.64 +dEQP-VK.ray_tracing.watertightness.7.256 +dEQP-VK.ray_tracing.watertightness.7.1024 +dEQP-VK.ray_tracing.watertightness.7.4096 +dEQP-VK.ray_tracing.watertightness.7.16384 +dEQP-VK.ray_tracing.watertightness.7.65536 +dEQP-VK.ray_tracing.watertightness.8.4 +dEQP-VK.ray_tracing.watertightness.8.16 +dEQP-VK.ray_tracing.watertightness.8.64 +dEQP-VK.ray_tracing.watertightness.8.256 +dEQP-VK.ray_tracing.watertightness.8.1024 +dEQP-VK.ray_tracing.watertightness.8.4096 +dEQP-VK.ray_tracing.watertightness.8.16384 +dEQP-VK.ray_tracing.watertightness.8.65536 +dEQP-VK.ray_tracing.watertightness.9.4 +dEQP-VK.ray_tracing.watertightness.9.16 +dEQP-VK.ray_tracing.watertightness.9.64 +dEQP-VK.ray_tracing.watertightness.9.256 +dEQP-VK.ray_tracing.watertightness.9.1024 +dEQP-VK.ray_tracing.watertightness.9.4096 +dEQP-VK.ray_tracing.watertightness.9.16384 +dEQP-VK.ray_tracing.watertightness.9.65536 diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index 9115d81..8c4cc88 100644 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -596047,3 +596047,83 @@ dEQP-VK.ray_tracing.acceleration_structures.operations.serialization.gpu_built.b dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_build_scratch dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_update_scratch dEQP-VK.ray_tracing.indirect.build_structure +dEQP-VK.ray_tracing.watertightness.0.4 +dEQP-VK.ray_tracing.watertightness.0.16 +dEQP-VK.ray_tracing.watertightness.0.64 +dEQP-VK.ray_tracing.watertightness.0.256 +dEQP-VK.ray_tracing.watertightness.0.1024 +dEQP-VK.ray_tracing.watertightness.0.4096 +dEQP-VK.ray_tracing.watertightness.0.16384 +dEQP-VK.ray_tracing.watertightness.0.65536 +dEQP-VK.ray_tracing.watertightness.1.4 +dEQP-VK.ray_tracing.watertightness.1.16 +dEQP-VK.ray_tracing.watertightness.1.64 +dEQP-VK.ray_tracing.watertightness.1.256 +dEQP-VK.ray_tracing.watertightness.1.1024 +dEQP-VK.ray_tracing.watertightness.1.4096 +dEQP-VK.ray_tracing.watertightness.1.16384 +dEQP-VK.ray_tracing.watertightness.1.65536 +dEQP-VK.ray_tracing.watertightness.2.4 +dEQP-VK.ray_tracing.watertightness.2.16 +dEQP-VK.ray_tracing.watertightness.2.64 +dEQP-VK.ray_tracing.watertightness.2.256 +dEQP-VK.ray_tracing.watertightness.2.1024 +dEQP-VK.ray_tracing.watertightness.2.4096 +dEQP-VK.ray_tracing.watertightness.2.16384 +dEQP-VK.ray_tracing.watertightness.2.65536 +dEQP-VK.ray_tracing.watertightness.3.4 +dEQP-VK.ray_tracing.watertightness.3.16 +dEQP-VK.ray_tracing.watertightness.3.64 +dEQP-VK.ray_tracing.watertightness.3.256 +dEQP-VK.ray_tracing.watertightness.3.1024 +dEQP-VK.ray_tracing.watertightness.3.4096 +dEQP-VK.ray_tracing.watertightness.3.16384 +dEQP-VK.ray_tracing.watertightness.3.65536 +dEQP-VK.ray_tracing.watertightness.4.4 +dEQP-VK.ray_tracing.watertightness.4.16 +dEQP-VK.ray_tracing.watertightness.4.64 +dEQP-VK.ray_tracing.watertightness.4.256 +dEQP-VK.ray_tracing.watertightness.4.1024 +dEQP-VK.ray_tracing.watertightness.4.4096 +dEQP-VK.ray_tracing.watertightness.4.16384 +dEQP-VK.ray_tracing.watertightness.4.65536 +dEQP-VK.ray_tracing.watertightness.5.4 +dEQP-VK.ray_tracing.watertightness.5.16 +dEQP-VK.ray_tracing.watertightness.5.64 +dEQP-VK.ray_tracing.watertightness.5.256 +dEQP-VK.ray_tracing.watertightness.5.1024 +dEQP-VK.ray_tracing.watertightness.5.4096 +dEQP-VK.ray_tracing.watertightness.5.16384 +dEQP-VK.ray_tracing.watertightness.5.65536 +dEQP-VK.ray_tracing.watertightness.6.4 +dEQP-VK.ray_tracing.watertightness.6.16 +dEQP-VK.ray_tracing.watertightness.6.64 +dEQP-VK.ray_tracing.watertightness.6.256 +dEQP-VK.ray_tracing.watertightness.6.1024 +dEQP-VK.ray_tracing.watertightness.6.4096 +dEQP-VK.ray_tracing.watertightness.6.16384 +dEQP-VK.ray_tracing.watertightness.6.65536 +dEQP-VK.ray_tracing.watertightness.7.4 +dEQP-VK.ray_tracing.watertightness.7.16 +dEQP-VK.ray_tracing.watertightness.7.64 +dEQP-VK.ray_tracing.watertightness.7.256 +dEQP-VK.ray_tracing.watertightness.7.1024 +dEQP-VK.ray_tracing.watertightness.7.4096 +dEQP-VK.ray_tracing.watertightness.7.16384 +dEQP-VK.ray_tracing.watertightness.7.65536 +dEQP-VK.ray_tracing.watertightness.8.4 +dEQP-VK.ray_tracing.watertightness.8.16 +dEQP-VK.ray_tracing.watertightness.8.64 +dEQP-VK.ray_tracing.watertightness.8.256 +dEQP-VK.ray_tracing.watertightness.8.1024 +dEQP-VK.ray_tracing.watertightness.8.4096 +dEQP-VK.ray_tracing.watertightness.8.16384 +dEQP-VK.ray_tracing.watertightness.8.65536 +dEQP-VK.ray_tracing.watertightness.9.4 +dEQP-VK.ray_tracing.watertightness.9.16 +dEQP-VK.ray_tracing.watertightness.9.64 +dEQP-VK.ray_tracing.watertightness.9.256 +dEQP-VK.ray_tracing.watertightness.9.1024 +dEQP-VK.ray_tracing.watertightness.9.4096 +dEQP-VK.ray_tracing.watertightness.9.16384 +dEQP-VK.ray_tracing.watertightness.9.65536 diff --git a/external/vulkancts/modules/vulkan/ray_tracing/CMakeLists.txt b/external/vulkancts/modules/vulkan/ray_tracing/CMakeLists.txt index 6700a9c..ffaf4dd 100644 --- a/external/vulkancts/modules/vulkan/ray_tracing/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/ray_tracing/CMakeLists.txt @@ -17,6 +17,8 @@ set(DEQP_VK_RAY_TRACING_SRCS vktRayTracingTraversalControlTests.hpp vktRayTracingAccelerationStructuresTests.cpp vktRayTracingAccelerationStructuresTests.hpp + vktRayTracingWatertightnessTests.cpp + vktRayTracingWatertightnessTests.hpp vktRayTracingTests.cpp vktRayTracingTests.hpp ) diff --git a/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp index 1663e3e..78e22ba 100644 --- a/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp +++ b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp @@ -30,6 +30,7 @@ #include "vktRayTracingTraversalControlTests.hpp" #include "vktRayTracingAccelerationStructuresTests.hpp" #include "vktRayTracingBuildIndirectTests.hpp" +#include "vktRayTracingWatertightnessTests.hpp" #include "deUniquePtr.hpp" @@ -52,6 +53,7 @@ tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx) group->addChild(createTraversalControlTests(testCtx)); group->addChild(createAccelerationStructuresTests(testCtx)); group->addChild(createBuildIndirectTests(testCtx)); + group->addChild(createWatertightnessTests(testCtx)); return group.release(); } diff --git a/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.cpp b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.cpp new file mode 100644 index 0000000..a941d73 --- /dev/null +++ b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.cpp @@ -0,0 +1,575 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 The Khronos Group 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 Ray Tracing Watertightness tests + *//*--------------------------------------------------------------------*/ + +#include "vktRayTracingWatertightnessTests.hpp" + +#include "vkDefs.hpp" + +#include "vktTestCase.hpp" +#include "vkCmdUtil.hpp" +#include "vkObjUtil.hpp" +#include "vkBuilderUtil.hpp" +#include "vkBarrierUtil.hpp" +#include "vkBufferWithMemory.hpp" +#include "vkImageWithMemory.hpp" +#include "vkTypeUtil.hpp" + +#include "vkRayTracingUtil.hpp" + +#include "deRandom.hpp" + +namespace vkt +{ +namespace RayTracing +{ +namespace +{ +using namespace vk; +using namespace std; + +static const VkFlags ALL_RAY_TRACING_STAGES = VK_SHADER_STAGE_RAYGEN_BIT_KHR + | VK_SHADER_STAGE_ANY_HIT_BIT_KHR + | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR + | VK_SHADER_STAGE_MISS_BIT_KHR + | VK_SHADER_STAGE_INTERSECTION_BIT_KHR + | VK_SHADER_STAGE_CALLABLE_BIT_KHR; + +struct CaseDef +{ + deUint32 width; + deUint32 height; + deUint32 squaresGroupCount; + deUint32 geometriesGroupCount; + deUint32 instancesGroupCount; + deUint32 randomSeed; +}; + +enum ShaderGroups +{ + FIRST_GROUP = 0, + RAYGEN_GROUP = FIRST_GROUP, + MISS_GROUP, + HIT_GROUP, + GROUP_COUNT +}; + +static inline tcu::Vec3 mixVec3(const tcu::Vec3& a, const tcu::Vec3& b, const float alpha) +{ + const tcu::Vec3 result = a * alpha + b * (1.0f - alpha); + + return result; +} + +deUint32 getShaderGroupSize (const InstanceInterface& vki, + const VkPhysicalDevice physicalDevice) +{ + de::MovePtr rayTracingPropertiesKHR; + + rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice); + + return rayTracingPropertiesKHR->getShaderGroupHandleSize(); +} + +deUint32 getShaderGroupBaseAlignment (const InstanceInterface& vki, + const VkPhysicalDevice physicalDevice) +{ + de::MovePtr rayTracingPropertiesKHR; + + rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice); + + return rayTracingPropertiesKHR->getShaderGroupBaseAlignment(); +} + +Move makePipeline (const DeviceInterface& vkd, + const VkDevice device, + vk::BinaryCollection& collection, + de::MovePtr& rayTracingPipeline, + VkPipelineLayout pipelineLayout, + const deUint32 raygenGroup, + const deUint32 missGroup, + const deUint32 hitGroup) +{ + Move raygenShader = createShaderModule(vkd, device, collection.get("rgen"), 0); + Move hitShader = createShaderModule(vkd, device, collection.get("ahit"), 0); + Move missShader = createShaderModule(vkd, device, collection.get("miss"), 0); + Move intersectionShader = createShaderModule(vkd, device, collection.get("sect"), 0); + + rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, raygenShader, raygenGroup); + rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR, hitShader, hitGroup); + rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR, missShader, missGroup); + rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR, intersectionShader, hitGroup); + + Move pipeline = rayTracingPipeline->createPipeline(vkd, device, pipelineLayout); + + return pipeline; +} + +VkImageCreateInfo makeImageCreateInfo (deUint32 width, deUint32 height, VkFormat format) +{ + const VkImageUsageFlags usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + const VkImageCreateInfo imageCreateInfo = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkImageCreateFlags)0u, // VkImageCreateFlags flags; + VK_IMAGE_TYPE_2D, // VkImageType imageType; + format, // VkFormat format; + makeExtent3D(width, height, 1u), // 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 imageCreateInfo; +} + +class RayTracingWatertightnessTestInstance : public TestInstance +{ +public: + RayTracingWatertightnessTestInstance (Context& context, const CaseDef& data); + ~RayTracingWatertightnessTestInstance (void); + tcu::TestStatus iterate (void); + +protected: + void checkSupportInInstance (void) const; + de::MovePtr runTest (void); + de::MovePtr initTopAccelerationStructure (VkCommandBuffer cmdBuffer, + vector >& bottomLevelAccelerationStructures); + vector > initBottomAccelerationStructures (VkCommandBuffer cmdBuffer); + de::MovePtr initBottomAccelerationStructure (VkCommandBuffer cmdBuffer, + bool triangles); + +private: + CaseDef m_data; +}; + +RayTracingWatertightnessTestInstance::RayTracingWatertightnessTestInstance (Context& context, const CaseDef& data) + : vkt::TestInstance (context) + , m_data (data) +{ +} + +RayTracingWatertightnessTestInstance::~RayTracingWatertightnessTestInstance (void) +{ +} + +class RayTracingTestCase : public TestCase +{ + public: + RayTracingTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data); + ~RayTracingTestCase (void); + + virtual void initPrograms (SourceCollections& programCollection) const; + virtual TestInstance* createInstance (Context& context) const; + virtual void checkSupport (Context& context) const; + +private: + CaseDef m_data; +}; + +RayTracingTestCase::RayTracingTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data) + : vkt::TestCase (context, name, desc) + , m_data (data) +{ +} + +RayTracingTestCase::~RayTracingTestCase (void) +{ +} + +void RayTracingTestCase::checkSupport(Context& context) const +{ + context.requireDeviceFunctionality(getRayTracingExtensionUsed()); + + const VkPhysicalDeviceRayTracingFeaturesKHR& rayTracingFeaturesKHR = context.getRayTracingFeatures(); + + if (rayTracingFeaturesKHR.rayTracing == DE_FALSE) + TCU_THROW(NotSupportedError, "Requires rayTracingFeaturesKHR.rayTracing"); +} + +void RayTracingTestCase::initPrograms (SourceCollections& programCollection) const +{ + { + std::stringstream css; + css << + "#version 460 core\n" + "#extension GL_EXT_nonuniform_qualifier : enable\n" + "#extension GL_EXT_ray_tracing : require\n" + "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" + "hitAttributeEXT vec3 attribs;\n" + "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n" + "void main()\n" + "{\n" + " uvec4 color = uvec4(1,0,0,1);\n" + " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n" + "}\n"; + + programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())); + } + + { + std::stringstream css; + css << + "#version 460 core\n" + "#extension GL_EXT_nonuniform_qualifier : enable\n" + "#extension GL_EXT_ray_tracing : require\n" + "layout(location = 0) rayPayloadInEXT dummyPayload { vec4 dummy; };\n" + "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n" + "void main()\n" + "{\n" + " uvec4 color = uvec4(2,0,0,1);\n" + " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n" + "}\n"; + + programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())); + } + + { + std::stringstream css; + css << + "#version 460 core\n" + "#extension GL_EXT_nonuniform_qualifier : enable\n" + "#extension GL_EXT_ray_tracing : require\n" + "hitAttributeEXT vec3 hitAttribute;\n" + "void main()\n" + "{\n" + " reportIntersectionEXT(1.0f, 0);\n" + "}\n"; + + programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())); + } + + programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())); +} + +TestInstance* RayTracingTestCase::createInstance (Context& context) const +{ + return new RayTracingWatertightnessTestInstance(context, m_data); +} + +de::MovePtr RayTracingWatertightnessTestInstance::initTopAccelerationStructure (VkCommandBuffer cmdBuffer, + vector >& bottomLevelAccelerationStructures) +{ + const DeviceInterface& vkd = m_context.getDeviceInterface(); + const VkDevice device = m_context.getDevice(); + Allocator& allocator = m_context.getDefaultAllocator(); + de::MovePtr result = makeTopLevelAccelerationStructure(); + + result->setInstanceCount(bottomLevelAccelerationStructures.size()); + + for (size_t structNdx = 0; structNdx < bottomLevelAccelerationStructures.size(); ++structNdx) + result->addInstance(bottomLevelAccelerationStructures[structNdx]); + + result->createAndBuild(vkd, device, cmdBuffer, allocator); + + return result; +} + +de::MovePtr RayTracingWatertightnessTestInstance::initBottomAccelerationStructure (VkCommandBuffer cmdBuffer, + bool triangle) +{ + const DeviceInterface& vkd = m_context.getDeviceInterface(); + const VkDevice device = m_context.getDevice(); + Allocator& allocator = m_context.getDefaultAllocator(); + de::MovePtr result = makeBottomLevelAccelerationStructure(); + de::Random rng (m_data.randomSeed); + std::vector vertices; + std::vector triangles; + std::vector geometryData; + + result->setGeometryCount(1u); + + vertices.reserve(3u * m_data.squaresGroupCount); + + vertices.push_back(tcu::Vec3(0.0f, 0.0f, -1.0f)); + vertices.push_back(tcu::Vec3(0.0f, 1.0f, -1.0f)); + vertices.push_back(tcu::Vec3(1.0f, 0.0f, -1.0f)); + vertices.push_back(tcu::Vec3(1.0f, 1.0f, -1.0f)); + + triangles.reserve(m_data.squaresGroupCount); + + triangles.push_back(tcu::UVec3(0, 1, 2)); + triangles.push_back(tcu::UVec3(1, 2, 3)); + + while (triangles.size() < m_data.squaresGroupCount) + { + const deUint32 n = (deUint32)rng.getInt(0, (deUint32)triangles.size() - 1); + tcu::UVec3& t = triangles[n]; + const tcu::Vec3& a = vertices[t.x()]; + const tcu::Vec3& b = vertices[t.y()]; + const tcu::Vec3& c = vertices[t.z()]; + const float alfa = rng.getFloat(0.01f, 0.99f); + const float beta = rng.getFloat(0.01f, 0.99f); + const tcu::Vec3 mixed = mixVec3(mixVec3(a, b, alfa), c, beta); + const float z = -rng.getFloat(0.01f, 0.99f); + const tcu::Vec3 d = tcu::Vec3(mixed.x(), mixed.y(), z); + const deUint32& p = t.x(); + const deUint32& q = t.y(); + deUint32& r = t.z(); + const deUint32 R = (deUint32)vertices.size(); + + vertices.push_back(d); + + triangles.push_back(tcu::UVec3(q, r, R)); + triangles.push_back(tcu::UVec3(p, r, R)); + r = R; + } + + geometryData.reserve(3u * triangles.size()); + + for (size_t i = 0; i < triangles.size(); ++i) + { + geometryData.push_back(vertices[triangles[i].x()]); + geometryData.push_back(vertices[triangles[i].y()]); + geometryData.push_back(vertices[triangles[i].z()]); + } + + result->addGeometry(geometryData, triangle); + result->createAndBuild(vkd, device, cmdBuffer, allocator); + + return result; +} + +vector > RayTracingWatertightnessTestInstance::initBottomAccelerationStructures (VkCommandBuffer cmdBuffer) +{ + vector > result; + + for (size_t instanceNdx = 0; instanceNdx < m_data.instancesGroupCount; ++instanceNdx) + { + de::MovePtr bottomLevelAccelerationStructure = initBottomAccelerationStructure(cmdBuffer, true); + + result.push_back(de::SharedPtr(bottomLevelAccelerationStructure.release())); + } + + return result; +} + +de::MovePtr RayTracingWatertightnessTestInstance::runTest (void) +{ + const InstanceInterface& vki = m_context.getInstanceInterface(); + const DeviceInterface& vkd = m_context.getDeviceInterface(); + const VkDevice device = m_context.getDevice(); + const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice(); + const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const VkQueue queue = m_context.getUniversalQueue(); + Allocator& allocator = m_context.getDefaultAllocator(); + const VkFormat format = VK_FORMAT_R32_UINT; + const deUint32 pixelCount = m_data.width * m_data.height; + const deUint32 shaderGroupHandleSize = getShaderGroupSize(vki, physicalDevice); + const deUint32 shaderGroupBaseAlignment = getShaderGroupBaseAlignment(vki, physicalDevice); + + const Move descriptorSetLayout = DescriptorSetLayoutBuilder() + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, ALL_RAY_TRACING_STAGES) + .addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES) + .build(vkd, device); + const Move descriptorPool = DescriptorPoolBuilder() + .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) + .addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) + .build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); + const Move descriptorSet = makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout); + const Move pipelineLayout = makePipelineLayout(vkd, device, descriptorSetLayout.get()); + const Move cmdPool = createCommandPool(vkd, device, 0, queueFamilyIndex); + const Move cmdBuffer = allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); + + de::MovePtr rayTracingPipeline = de::newMovePtr(); + const Move pipeline = makePipeline(vkd, device, m_context.getBinaryCollection(), rayTracingPipeline, *pipelineLayout, RAYGEN_GROUP, MISS_GROUP, HIT_GROUP); + const de::MovePtr raygenShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, RAYGEN_GROUP, 1u); + const de::MovePtr missShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, MISS_GROUP, 1u); + const de::MovePtr hitShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, HIT_GROUP, 1u); + const VkStridedBufferRegionKHR raygenShaderBindingTableRegion = makeStridedBufferRegionKHR(raygenShaderBindingTable->get(), 0, 0, shaderGroupHandleSize); + const VkStridedBufferRegionKHR missShaderBindingTableRegion = makeStridedBufferRegionKHR(missShaderBindingTable->get(), 0, 0, shaderGroupHandleSize); + const VkStridedBufferRegionKHR hitShaderBindingTableRegion = makeStridedBufferRegionKHR(hitShaderBindingTable->get(), 0, 0, shaderGroupHandleSize); + const VkStridedBufferRegionKHR callableShaderBindingTableRegion = makeStridedBufferRegionKHR(DE_NULL, 0, 0, 0); + + const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_data.width, m_data.height, format); + const VkImageSubresourceRange imageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0, 1u); + const de::MovePtr image = de::MovePtr(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any)); + const Move imageView = makeImageView(vkd, device, **image, VK_IMAGE_VIEW_TYPE_2D, format, imageSubresourceRange); + + const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(pixelCount*sizeof(deUint32), VK_BUFFER_USAGE_TRANSFER_DST_BIT); + const VkImageSubresourceLayers bufferImageSubresourceLayers = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u); + const VkBufferImageCopy bufferImageRegion = makeBufferImageCopy(makeExtent3D(m_data.width, m_data.height, 1u), bufferImageSubresourceLayers); + de::MovePtr buffer = de::MovePtr(new BufferWithMemory(vkd, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible)); + + const VkDescriptorImageInfo descriptorImageInfo = makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL); + + const VkImageMemoryBarrier preImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + **image, imageSubresourceRange); + const VkImageMemoryBarrier postImageBarrier = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + **image, imageSubresourceRange); + const VkMemoryBarrier preTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); + const VkMemoryBarrier postTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT); + const VkMemoryBarrier postCopyMemoryBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_READ_BIT, 0); + const VkClearValue clearValue = makeClearValueColorU32(5u, 5u, 5u, 255u); + + vector > bottomLevelAccelerationStructures; + de::MovePtr topLevelAccelerationStructure; + + beginCommandBuffer(vkd, *cmdBuffer, 0u); + { + cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &preImageBarrier); + vkd.cmdClearColorImage(*cmdBuffer, **image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue.color, 1, &imageSubresourceRange); + cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, ALL_RAY_TRACING_STAGES, &postImageBarrier); + + bottomLevelAccelerationStructures = initBottomAccelerationStructures(*cmdBuffer); + topLevelAccelerationStructure = initTopAccelerationStructure(*cmdBuffer, bottomLevelAccelerationStructures); + + cmdPipelineMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, ALL_RAY_TRACING_STAGES, &preTraceMemoryBarrier); + + const TopLevelAccelerationStructure* topLevelAccelerationStructurePtr = topLevelAccelerationStructure.get(); + VkWriteDescriptorSetAccelerationStructureKHR accelerationStructureWriteDescriptorSet = + { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1u, // deUint32 accelerationStructureCount; + topLevelAccelerationStructurePtr->getPtr(), // const VkAccelerationStructureKHR* pAccelerationStructures; + }; + + DescriptorSetUpdateBuilder() + .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo) + .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet) + .update(vkd, device); + + vkd.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *pipelineLayout, 0, 1, &descriptorSet.get(), 0, DE_NULL); + + vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *pipeline); + + cmdTraceRays(vkd, + *cmdBuffer, + &raygenShaderBindingTableRegion, + &missShaderBindingTableRegion, + &hitShaderBindingTableRegion, + &callableShaderBindingTableRegion, + m_data.width, m_data.height, 1); + + cmdPipelineMemoryBarrier(vkd, *cmdBuffer, ALL_RAY_TRACING_STAGES, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTraceMemoryBarrier); + + vkd.cmdCopyImageToBuffer(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **buffer, 1u, &bufferImageRegion); + + cmdPipelineMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, &postCopyMemoryBarrier); + } + endCommandBuffer(vkd, *cmdBuffer); + + submitCommandsAndWait(vkd, device, queue, cmdBuffer.get()); + + invalidateMappedMemoryRange(vkd, device, buffer->getAllocation().getMemory(), buffer->getAllocation().getOffset(), pixelCount * sizeof(deUint32)); + + return buffer; +} + +void RayTracingWatertightnessTestInstance::checkSupportInInstance (void) const +{ + const InstanceInterface& vki = m_context.getInstanceInterface(); + const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice(); + const vk::VkPhysicalDeviceProperties& properties = m_context.getDeviceProperties(); + const deUint32 requiredAllocations = 8u + + TopLevelAccelerationStructure::getRequiredAllocationCount() + + m_data.instancesGroupCount * BottomLevelAccelerationStructure::getRequiredAllocationCount(); + de::MovePtr rayTracingProperties = makeRayTracingProperties(vki, physicalDevice); + + if (rayTracingProperties->getMaxPrimitiveCount() < m_data.squaresGroupCount) + TCU_THROW(NotSupportedError, "Triangles required more than supported"); + + if (rayTracingProperties->getMaxGeometryCount() < m_data.geometriesGroupCount) + TCU_THROW(NotSupportedError, "Geometries required more than supported"); + + if (rayTracingProperties->getMaxInstanceCount() < m_data.instancesGroupCount) + TCU_THROW(NotSupportedError, "Instances required more than supported"); + + if (properties.limits.maxMemoryAllocationCount < requiredAllocations) + TCU_THROW(NotSupportedError, "Test requires more allocations allowed"); +} + +tcu::TestStatus RayTracingWatertightnessTestInstance::iterate (void) +{ + checkSupportInInstance(); + + const de::MovePtr bufferGPU = runTest(); + const deUint32* bufferPtrGPU = (deUint32*)bufferGPU->getAllocation().getHostPtr(); + deUint32 failures = 0; + deUint32 pos = 0; + + for (deUint32 y = 0; y < m_data.height; ++y) + for (deUint32 x = 0; x < m_data.width; ++x) + { + if (bufferPtrGPU[pos] != 1) + failures++; + + ++pos; + } + + if (failures == 0) + return tcu::TestStatus::pass("Pass"); + else + return tcu::TestStatus::fail("failures=" + de::toString(failures)); +} + +} // anonymous + +tcu::TestCaseGroup* createWatertightnessTests (tcu::TestContext& testCtx) +{ + de::MovePtr watertightnessGroup(new tcu::TestCaseGroup(testCtx, "watertightness", "Ray watertightness tests")); + + const size_t numTests = 10; + const deUint32 sizes[] = { 4, 16, 64, 256, 1024, 4096, 16384, 65536 }; + + for (size_t testNdx = 0; testNdx < numTests; ++testNdx) + { + de::MovePtr group(new tcu::TestCaseGroup(testCtx, de::toString(testNdx).c_str(), "")); + + for (size_t sizesNdx = 0; sizesNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizesNdx) + { + const deUint32 squaresGroupCount = sizes[sizesNdx]; + const deUint32 geometriesGroupCount = 1; + const deUint32 instancesGroupCount = 1; + const deUint32 randomSeed = (deUint32)(5 * testNdx + 11 * sizes[sizesNdx]); + const CaseDef caseDef = + { + 256u, + 256u, + squaresGroupCount, + geometriesGroupCount, + instancesGroupCount, + randomSeed + }; + const std::string testName = de::toString(caseDef.squaresGroupCount); + + group->addChild(new RayTracingTestCase(testCtx, testName.c_str(), "", caseDef)); + } + + watertightnessGroup->addChild(group.release()); + } + + return watertightnessGroup.release(); +} + +} // RayTracing +} // vkt diff --git a/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.hpp b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.hpp new file mode 100644 index 0000000..7c49d69 --- /dev/null +++ b/external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingWatertightnessTests.hpp @@ -0,0 +1,39 @@ +#ifndef _VKTRAYTRACINGWATERTIGHTNESSTESTS_HPP +#define _VKTRAYTRACINGWATERTIGHTNESSTESTS_HPP +/*------------------------------------------------------------------------- + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 The Khronos Group 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 Ray Tracing Watertightness tests + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "tcuTestCase.hpp" + +namespace vkt +{ +namespace RayTracing +{ + +tcu::TestCaseGroup* createWatertightnessTests (tcu::TestContext& testCtx); + +} // RayTracing +} // vkt + +#endif // _VKTRAYTRACINGWATERTIGHTNESSTESTS_HPP diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt index b440c11..1bfad7e 100644 --- a/external/vulkancts/mustpass/master/vk-default.txt +++ b/external/vulkancts/mustpass/master/vk-default.txt @@ -598317,3 +598317,83 @@ dEQP-VK.ray_tracing.acceleration_structures.operations.serialization.gpu_built.b dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_build_scratch dEQP-VK.ray_tracing.acceleration_structures.requirements.memory_update_scratch dEQP-VK.ray_tracing.indirect.build_structure +dEQP-VK.ray_tracing.watertightness.0.4 +dEQP-VK.ray_tracing.watertightness.0.16 +dEQP-VK.ray_tracing.watertightness.0.64 +dEQP-VK.ray_tracing.watertightness.0.256 +dEQP-VK.ray_tracing.watertightness.0.1024 +dEQP-VK.ray_tracing.watertightness.0.4096 +dEQP-VK.ray_tracing.watertightness.0.16384 +dEQP-VK.ray_tracing.watertightness.0.65536 +dEQP-VK.ray_tracing.watertightness.1.4 +dEQP-VK.ray_tracing.watertightness.1.16 +dEQP-VK.ray_tracing.watertightness.1.64 +dEQP-VK.ray_tracing.watertightness.1.256 +dEQP-VK.ray_tracing.watertightness.1.1024 +dEQP-VK.ray_tracing.watertightness.1.4096 +dEQP-VK.ray_tracing.watertightness.1.16384 +dEQP-VK.ray_tracing.watertightness.1.65536 +dEQP-VK.ray_tracing.watertightness.2.4 +dEQP-VK.ray_tracing.watertightness.2.16 +dEQP-VK.ray_tracing.watertightness.2.64 +dEQP-VK.ray_tracing.watertightness.2.256 +dEQP-VK.ray_tracing.watertightness.2.1024 +dEQP-VK.ray_tracing.watertightness.2.4096 +dEQP-VK.ray_tracing.watertightness.2.16384 +dEQP-VK.ray_tracing.watertightness.2.65536 +dEQP-VK.ray_tracing.watertightness.3.4 +dEQP-VK.ray_tracing.watertightness.3.16 +dEQP-VK.ray_tracing.watertightness.3.64 +dEQP-VK.ray_tracing.watertightness.3.256 +dEQP-VK.ray_tracing.watertightness.3.1024 +dEQP-VK.ray_tracing.watertightness.3.4096 +dEQP-VK.ray_tracing.watertightness.3.16384 +dEQP-VK.ray_tracing.watertightness.3.65536 +dEQP-VK.ray_tracing.watertightness.4.4 +dEQP-VK.ray_tracing.watertightness.4.16 +dEQP-VK.ray_tracing.watertightness.4.64 +dEQP-VK.ray_tracing.watertightness.4.256 +dEQP-VK.ray_tracing.watertightness.4.1024 +dEQP-VK.ray_tracing.watertightness.4.4096 +dEQP-VK.ray_tracing.watertightness.4.16384 +dEQP-VK.ray_tracing.watertightness.4.65536 +dEQP-VK.ray_tracing.watertightness.5.4 +dEQP-VK.ray_tracing.watertightness.5.16 +dEQP-VK.ray_tracing.watertightness.5.64 +dEQP-VK.ray_tracing.watertightness.5.256 +dEQP-VK.ray_tracing.watertightness.5.1024 +dEQP-VK.ray_tracing.watertightness.5.4096 +dEQP-VK.ray_tracing.watertightness.5.16384 +dEQP-VK.ray_tracing.watertightness.5.65536 +dEQP-VK.ray_tracing.watertightness.6.4 +dEQP-VK.ray_tracing.watertightness.6.16 +dEQP-VK.ray_tracing.watertightness.6.64 +dEQP-VK.ray_tracing.watertightness.6.256 +dEQP-VK.ray_tracing.watertightness.6.1024 +dEQP-VK.ray_tracing.watertightness.6.4096 +dEQP-VK.ray_tracing.watertightness.6.16384 +dEQP-VK.ray_tracing.watertightness.6.65536 +dEQP-VK.ray_tracing.watertightness.7.4 +dEQP-VK.ray_tracing.watertightness.7.16 +dEQP-VK.ray_tracing.watertightness.7.64 +dEQP-VK.ray_tracing.watertightness.7.256 +dEQP-VK.ray_tracing.watertightness.7.1024 +dEQP-VK.ray_tracing.watertightness.7.4096 +dEQP-VK.ray_tracing.watertightness.7.16384 +dEQP-VK.ray_tracing.watertightness.7.65536 +dEQP-VK.ray_tracing.watertightness.8.4 +dEQP-VK.ray_tracing.watertightness.8.16 +dEQP-VK.ray_tracing.watertightness.8.64 +dEQP-VK.ray_tracing.watertightness.8.256 +dEQP-VK.ray_tracing.watertightness.8.1024 +dEQP-VK.ray_tracing.watertightness.8.4096 +dEQP-VK.ray_tracing.watertightness.8.16384 +dEQP-VK.ray_tracing.watertightness.8.65536 +dEQP-VK.ray_tracing.watertightness.9.4 +dEQP-VK.ray_tracing.watertightness.9.16 +dEQP-VK.ray_tracing.watertightness.9.64 +dEQP-VK.ray_tracing.watertightness.9.256 +dEQP-VK.ray_tracing.watertightness.9.1024 +dEQP-VK.ray_tracing.watertightness.9.4096 +dEQP-VK.ray_tracing.watertightness.9.16384 +dEQP-VK.ray_tracing.watertightness.9.65536 -- 2.7.4