| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2020 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 Builtin and specialization constant tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktRayTracingBuiltinTests.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 "vkImageUtil.hpp" |
| |
| #include "vkRayTracingUtil.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuMatrix.hpp" |
| |
| #include "deMath.h" |
| |
| 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; |
| |
| enum GeomType |
| { |
| GEOM_TYPE_TRIANGLES, |
| GEOM_TYPE_AABBS, |
| }; |
| |
| enum TestId |
| { |
| TEST_ID_LAUNCH_ID_EXT = 0, |
| TEST_ID_LAUNCH_SIZE_EXT, |
| TEST_ID_PRIMITIVE_ID, |
| TEST_ID_INSTANCE_ID, |
| TEST_ID_INSTANCE_CUSTOM_INDEX_EXT, |
| TEST_ID_GEOMETRY_INDEX_EXT, |
| TEST_ID_WORLD_RAY_ORIGIN_EXT, |
| TEST_ID_WORLD_RAY_DIRECTION_EXT, |
| TEST_ID_OBJECT_RAY_ORIGIN_EXT, |
| TEST_ID_OBJECT_RAY_DIRECTION_EXT, |
| TEST_ID_RAY_T_MIN_EXT, |
| TEST_ID_RAY_T_MAX_EXT, |
| TEST_ID_INCOMING_RAY_FLAGS_EXT, |
| TEST_ID_HIT_T_EXT, |
| TEST_ID_HIT_KIND_EXT, |
| TEST_ID_OBJECT_TO_WORLD_EXT, |
| TEST_ID_OBJECT_TO_WORLD_3X4_EXT, |
| TEST_ID_WORLD_TO_OBJECT_EXT, |
| TEST_ID_WORLD_TO_OBJECT_3X4_EXT, |
| TEST_ID_LAST |
| }; |
| |
| enum RayFlagBits |
| { |
| RAY_FLAG_BIT_OPAQUE_EXT = 0, // const uint gl_RayFlagsOpaqueEXT = 1U; |
| RAY_FLAG_BIT_NO_OPAQUE_EXT = 1, // const uint gl_RayFlagsNoOpaqueEXT = 2U; |
| RAY_FLAG_BIT_TERMINATE_ON_FIRST_HIT_EXT = 2, // const uint gl_RayFlagsTerminateOnFirstHitEXT = 4U; |
| RAY_FLAG_BIT_SKIP_CLOSEST_HIT_SHADER_EXT = 3, // const uint gl_RayFlagsSkipClosestHitShaderEXT = 8U; |
| RAY_FLAG_BIT_CULL_BACK_FACING_TRIANGLES_EXT = 4, // const uint gl_RayFlagsCullBackFacingTrianglesEXT = 16U; |
| RAY_FLAG_BIT_CULL_FRONT_FACING_TRIANGLES_EXT = 5, // const uint gl_RayFlagsCullFrontFacingTrianglesEXT = 32U; |
| RAY_FLAG_BIT_CULL_OPAQUE_EXT = 6, // const uint gl_RayFlagsCullOpaqueEXT = 64U; |
| RAY_FLAG_BIT_CULL_NO_OPAQUE_EXT = 7, // const uint gl_RayFlagsCullNoOpaqueEXT = 128U; |
| RAY_FLAG_BIT_LAST_PER_TEST, |
| RAY_FLAG_BIT_SKIP_TRIANGLES_EXT = 8, // const uint gl_RayFlagsSkipTrianglesEXT = 256U; |
| RAY_FLAG_BIT_SKIP_AABB_EXT = 9, // const uint gl_RayFlagsSkipAABBEXT = 512U; |
| RAY_FLAG_BIT_LAST |
| }; |
| |
| struct CaseDef |
| { |
| TestId id; |
| const char* name; |
| deUint32 width; |
| deUint32 height; |
| deUint32 depth; |
| deUint32 raysDepth; |
| VkFormat format; |
| bool fixedPointScalarOutput; |
| bool fixedPointVectorOutput; |
| bool fixedPointMatrixOutput; |
| GeomType geomType; |
| deUint32 squaresGroupCount; |
| deUint32 geometriesGroupCount; |
| deUint32 instancesGroupCount; |
| VkShaderStageFlagBits stage; |
| bool rayFlagSkipTriangles; |
| bool rayFlagSkipAABSs; |
| bool opaque; |
| bool frontFace; |
| VkPipelineCreateFlags pipelineCreateFlags; |
| bool useSpecConstants; |
| }; |
| |
| const deUint32 DEFAULT_UINT_CLEAR_VALUE = 0x8000; |
| const deUint32 FIXED_POINT_DIVISOR = 1024 * 1024; |
| const deUint32 FIXED_POINT_ALLOWED_ERROR = 4; |
| |
| bool isPlain (const deUint32 width, const deUint32 height, const deUint32 depth) |
| { |
| return (width == 1 || height == 1 || depth == 1); |
| } |
| |
| deUint32 getShaderGroupSize (const InstanceInterface& vki, |
| const VkPhysicalDevice physicalDevice) |
| { |
| de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR; |
| |
| rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice); |
| return rayTracingPropertiesKHR->getShaderGroupHandleSize(); |
| } |
| |
| deUint32 getShaderGroupBaseAlignment (const InstanceInterface& vki, |
| const VkPhysicalDevice physicalDevice) |
| { |
| de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR; |
| |
| rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice); |
| return rayTracingPropertiesKHR->getShaderGroupBaseAlignment(); |
| } |
| |
| VkImageCreateInfo makeImageCreateInfo (deUint32 width, deUint32 height, deUint32 depth, VkFormat format) |
| { |
| const VkImageType imageType = VK_IMAGE_TYPE_3D; |
| 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; |
| imageType, // VkImageType imageType; |
| format, // VkFormat format; |
| makeExtent3D(width, height, depth), // 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 RayTracingBuiltinLaunchTestInstance : public TestInstance |
| { |
| public: |
| RayTracingBuiltinLaunchTestInstance (Context& context, const CaseDef& data); |
| ~RayTracingBuiltinLaunchTestInstance (void); |
| tcu::TestStatus iterate (void); |
| |
| protected: |
| void checkSupportInInstance (void) const; |
| Move<VkPipeline> makePipeline (de::MovePtr<RayTracingPipeline>& rayTracingPipeline, |
| VkPipelineLayout pipelineLayout, |
| const VkSpecializationInfo* specializationInfo); |
| std::vector<deInt32> expectedIntValuesBuffer (void); |
| std::vector<float> expectedFloatValuesBuffer (void); |
| std::vector<float> expectedVectorValuesBuffer (void); |
| std::vector<float> expectedMatrixValuesBuffer (void); |
| de::MovePtr<BufferWithMemory> runTest (void); |
| de::MovePtr<BufferWithMemory> createShaderBindingTable (const InstanceInterface& vki, |
| const DeviceInterface& vkd, |
| const VkDevice device, |
| const VkPhysicalDevice physicalDevice, |
| const VkPipeline pipeline, |
| Allocator& allocator, |
| de::MovePtr<RayTracingPipeline>& rayTracingPipeline, |
| const deUint32 group); |
| |
| bool validateIntBuffer (de::MovePtr<BufferWithMemory> buffer); |
| bool validateFloatBuffer (de::MovePtr<BufferWithMemory> buffer); |
| bool validateVectorBuffer (de::MovePtr<BufferWithMemory> buffer); |
| bool validateMatrixBuffer (de::MovePtr<BufferWithMemory> buffer); |
| |
| de::MovePtr<TopLevelAccelerationStructure> initTopAccelerationStructure (VkCommandBuffer cmdBuffer, |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> >& bottomLevelAccelerationStructures); |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> > initBottomAccelerationStructures (VkCommandBuffer cmdBuffer); |
| de::MovePtr<BottomLevelAccelerationStructure> initBottomAccelerationStructure (VkCommandBuffer cmdBuffer, |
| tcu::UVec2& startPos); |
| |
| private: |
| CaseDef m_data; |
| VkShaderStageFlags m_shaders; |
| deUint32 m_raygenShaderGroup; |
| deUint32 m_missShaderGroup; |
| deUint32 m_hitShaderGroup; |
| deUint32 m_callableShaderGroup; |
| deUint32 m_shaderGroupCount; |
| }; |
| |
| RayTracingBuiltinLaunchTestInstance::RayTracingBuiltinLaunchTestInstance (Context& context, const CaseDef& data) |
| : vkt::TestInstance (context) |
| , m_data (data) |
| , m_shaders (0) |
| , m_raygenShaderGroup (~0u) |
| , m_missShaderGroup (~0u) |
| , m_hitShaderGroup (~0u) |
| , m_callableShaderGroup (~0u) |
| , m_shaderGroupCount (0) |
| { |
| const VkShaderStageFlags hitStages = VK_SHADER_STAGE_ANY_HIT_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR; |
| BinaryCollection& collection = m_context.getBinaryCollection(); |
| deUint32 group = 0; |
| deUint32 shaderCount = 0; |
| |
| if (collection.contains("rgen")) m_shaders |= VK_SHADER_STAGE_RAYGEN_BIT_KHR; |
| if (collection.contains("ahit")) m_shaders |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR; |
| if (collection.contains("chit")) m_shaders |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR; |
| if (collection.contains("miss")) m_shaders |= VK_SHADER_STAGE_MISS_BIT_KHR; |
| if (collection.contains("sect")) m_shaders |= VK_SHADER_STAGE_INTERSECTION_BIT_KHR; |
| if (collection.contains("call")) m_shaders |= VK_SHADER_STAGE_CALLABLE_BIT_KHR; |
| |
| for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it) |
| shaderCount++; |
| |
| if (shaderCount != (deUint32)dePop32(m_shaders)) |
| TCU_THROW(InternalError, "Unused shaders detected in the collection"); |
| |
| if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR)) |
| m_raygenShaderGroup = group++; |
| |
| if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR)) |
| m_missShaderGroup = group++; |
| |
| if (0 != (m_shaders & hitStages)) |
| m_hitShaderGroup = group++; |
| |
| if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR)) |
| m_callableShaderGroup = group++; |
| |
| m_shaderGroupCount = group; |
| } |
| |
| RayTracingBuiltinLaunchTestInstance::~RayTracingBuiltinLaunchTestInstance (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: |
| static inline const std::string getIntersectionPassthrough (void); |
| static inline const std::string getMissPassthrough (void); |
| static inline const std::string getHitPassthrough (void); |
| |
| 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 |
| { |
| const bool pipelineFlagSkipTriangles = ((m_data.pipelineCreateFlags & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) != 0); |
| const bool pipelineFlagSkipAABSs = ((m_data.pipelineCreateFlags & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR) != 0); |
| const bool cullingFlags = m_data.rayFlagSkipTriangles |
| || m_data.rayFlagSkipAABSs |
| || pipelineFlagSkipTriangles |
| || pipelineFlagSkipAABSs; |
| |
| context.requireDeviceFunctionality("VK_KHR_acceleration_structure"); |
| context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline"); |
| |
| const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures(); |
| if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE ) |
| TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline"); |
| |
| const VkPhysicalDeviceAccelerationStructureFeaturesKHR& accelerationStructureFeaturesKHR = context.getAccelerationStructureFeatures(); |
| if (accelerationStructureFeaturesKHR.accelerationStructure == DE_FALSE) |
| TCU_THROW(TestError, "VK_KHR_ray_tracing_pipeline requires VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure"); |
| |
| if (cullingFlags && rayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling == DE_FALSE) |
| TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling"); |
| } |
| |
| const std::string RayTracingTestCase::getIntersectionPassthrough (void) |
| { |
| const std::string intersectionPassthrough = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " reportIntersectionEXT(0.95f, 0x7Eu);\n" |
| "}\n"; |
| |
| return intersectionPassthrough; |
| } |
| |
| const std::string RayTracingTestCase::getMissPassthrough (void) |
| { |
| const std::string missPassthrough = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| return missPassthrough; |
| } |
| |
| const std::string RayTracingTestCase::getHitPassthrough (void) |
| { |
| const std::string hitPassthrough = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| return hitPassthrough; |
| } |
| |
| void RayTracingTestCase::initPrograms (SourceCollections& programCollection) const |
| { |
| const bool useSC = m_data.useSpecConstants; |
| DE_ASSERT(!useSC || m_data.id == TEST_ID_LAUNCH_ID_EXT); |
| |
| const vk::ShaderBuildOptions buildOptions(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true); |
| |
| if (m_data.id == TEST_ID_LAUNCH_ID_EXT || m_data.id == TEST_ID_LAUNCH_SIZE_EXT) |
| { |
| const std::string specConstants = |
| "layout (constant_id=0) const highp int factor1 = 1;\n" |
| "layout (constant_id=1) const highp float factor2 = 2.0;\n" |
| ; |
| |
| const std::string updateImage = |
| " ivec3 p = ivec3(gl_LaunchIDEXT);\n" |
| " ivec3 v = ivec3(gl_" + std::string(m_data.name) + ");\n" |
| " int r = v.x + " + (useSC ? "factor1" : "256") + " * (v.y + " + (useSC ? "int(factor2)" : "256") + " * v.z) + 1;\n" |
| " ivec4 c = ivec4(r,0,0,1);\n" |
| " imageStore(result, p, c);\n"; |
| |
| switch (m_data.stage) |
| { |
| case VK_SHADER_STAGE_RAYGEN_BIT_KHR: |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| " hitAttribute = vec3(0.0f, 0.0f, 0.0f);\n" |
| " reportIntersectionEXT(1.0f, 0);\n" |
| "}\n"; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_MISS_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CALLABLE_BIT_KHR: |
| { |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) callableDataEXT float dummy;" |
| "layout(set = 0, binding = 1) uniform accelerationStructureEXT topLevelAS;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " executeCallableEXT(0, 0);\n" |
| "}\n"; |
| |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| << (useSC ? specConstants : "") << |
| "layout(location = 0) callableDataInEXT float dummy;" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("call") << glu::CallableSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| default: |
| TCU_THROW(InternalError, "Unknown stage"); |
| } |
| } |
| else if (m_data.id == TEST_ID_GEOMETRY_INDEX_EXT || |
| m_data.id == TEST_ID_PRIMITIVE_ID || |
| m_data.id == TEST_ID_INSTANCE_ID || |
| m_data.id == TEST_ID_INSTANCE_CUSTOM_INDEX_EXT || |
| m_data.id == TEST_ID_HIT_KIND_EXT ) |
| { |
| const std::string conditionGeometryIndex = " int n = int(gl_LaunchIDEXT.x + gl_LaunchSizeEXT.x * (gl_LaunchIDEXT.y + gl_LaunchSizeEXT.y * gl_LaunchIDEXT.z));\n" |
| " int m = (n / " + de::toString(m_data.squaresGroupCount) + ") % " + de::toString(m_data.geometriesGroupCount) + ";\n" |
| " if (r == m)"; |
| const std::string conditionPrimitiveId = " int n = int(gl_LaunchIDEXT.x + gl_LaunchSizeEXT.x * (gl_LaunchIDEXT.y + gl_LaunchSizeEXT.y * gl_LaunchIDEXT.z));\n" |
| " int m = n % " + de::toString(m_data.squaresGroupCount) + ";\n" |
| " if (r == m)"; |
| const std::string condition = (m_data.id == TEST_ID_GEOMETRY_INDEX_EXT) && (m_data.geomType == GEOM_TYPE_AABBS) ? conditionGeometryIndex |
| : (m_data.id == TEST_ID_PRIMITIVE_ID) && (m_data.geomType == GEOM_TYPE_AABBS) ? conditionPrimitiveId |
| : ""; |
| const std::string updateImage = |
| " ivec3 p = ivec3(gl_LaunchIDEXT);\n" |
| " int r = int(gl_" + std::string(m_data.name) + ");\n" |
| " ivec4 c = ivec4(r,0,0,1);\n" |
| + condition + " imageStore(result, p, c);\n"; |
| |
| switch (m_data.stage) |
| { |
| case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(getIntersectionPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| { |
| const std::string intersectionShaderSingle = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " int r = int(gl_" + std::string(m_data.name) + ");\n" |
| + condition + " reportIntersectionEXT(0.95f, 0x7Eu);\n" |
| "}\n"; |
| const std::string intersectionShader = condition.empty() ? getIntersectionPassthrough() : intersectionShaderSingle; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| } |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| " reportIntersectionEXT(0.95f, 0);\n" |
| "}\n"; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| default: |
| TCU_THROW(InternalError, "Unknown stage"); |
| } |
| } |
| else if (m_data.id == TEST_ID_INCOMING_RAY_FLAGS_EXT) |
| { |
| const bool cullingFlags = m_data.rayFlagSkipTriangles || m_data.rayFlagSkipAABSs; |
| const std::string cullingFlagsInit = (m_data.rayFlagSkipTriangles && m_data.rayFlagSkipAABSs) ? "gl_RayFlagsSkipTrianglesEXT|gl_RayFlagsSkipAABBEXT" |
| : m_data.rayFlagSkipTriangles ? "gl_RayFlagsSkipTrianglesEXT" |
| : m_data.rayFlagSkipAABSs ? "gl_RayFlagsSkipAABBEXT" |
| : "gl_RayFlagsNoneEXT"; |
| const std::string updateImage = |
| " ivec3 p = ivec3(gl_LaunchIDEXT);\n" |
| " int r = int(gl_" + std::string(m_data.name) + ");\n" |
| " ivec4 c = ivec4(r,0,0,1);\n" |
| " imageStore(result, p, c);\n"; |
| const std::string intersectionShader = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint hitKind = " + std::string(m_data.frontFace ? "0x7Eu" : "0x7Fu") + ";\n" |
| " reportIntersectionEXT(0.95f, hitKind);\n" |
| "}\n"; |
| const std::string raygenFlagsFragment = |
| "\n" |
| " if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_OPAQUE_EXT ) + "))) f = f | gl_RayFlagsOpaqueEXT;\n" |
| " else if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_NO_OPAQUE_EXT ) + "))) f = f | gl_RayFlagsNoOpaqueEXT;\n" |
| " else if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_CULL_OPAQUE_EXT ) + "))) f = f | gl_RayFlagsCullOpaqueEXT;\n" |
| " else if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_CULL_NO_OPAQUE_EXT ) + "))) f = f | gl_RayFlagsCullNoOpaqueEXT;\n" |
| "\n" |
| " if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_CULL_BACK_FACING_TRIANGLES_EXT ) + "))) f = f | gl_RayFlagsCullBackFacingTrianglesEXT;\n" |
| " else if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_CULL_FRONT_FACING_TRIANGLES_EXT) + "))) f = f | gl_RayFlagsCullFrontFacingTrianglesEXT;\n" |
| "\n" |
| " if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_TERMINATE_ON_FIRST_HIT_EXT ) + "))) f = f | gl_RayFlagsTerminateOnFirstHitEXT;\n" |
| " if (0 != (n & (1<<" + de::toString(RAY_FLAG_BIT_SKIP_CLOSEST_HIT_SHADER_EXT ) + "))) f = f | gl_RayFlagsSkipClosestHitShaderEXT;\n" |
| "\n"; |
| const std::string raygenShader = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| + (cullingFlags ? std::string("#extension GL_EXT_ray_flags_primitive_culling : require\n") : "") + |
| "layout(location = 0) rayPayloadEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 1) uniform accelerationStructureEXT topLevelAS;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint n = gl_LaunchIDEXT.x + gl_LaunchSizeEXT.x * (gl_LaunchIDEXT.y + gl_LaunchSizeEXT.y * gl_LaunchIDEXT.z);\n" |
| " uint f = " + cullingFlagsInit + ";\n" |
| + raygenFlagsFragment + |
| " uint rayFlags = f;\n" |
| " uint cullMask = 0xFF;\n" |
| " float tmin = 0.0;\n" |
| " float tmax = 9.0;\n" |
| " vec3 origin = vec3((float(gl_LaunchIDEXT.x) + 0.5f) / float(gl_LaunchSizeEXT.x), (float(gl_LaunchIDEXT.y) + 0.5f) / float(gl_LaunchSizeEXT.y), 0.0);\n" |
| " vec3 direct = vec3(0.0, 0.0, -1.0);\n" |
| " traceRayEXT(topLevelAS, rayFlags, cullMask, 0, 0, 0, origin, tmin, direct, tmax, 0);\n" |
| "}\n"; |
| |
| switch (m_data.stage) |
| { |
| case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_MISS_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| default: |
| TCU_THROW(InternalError, "Unknown stage"); |
| } |
| } |
| else if (m_data.id == TEST_ID_HIT_T_EXT || |
| m_data.id == TEST_ID_RAY_T_MIN_EXT || |
| m_data.id == TEST_ID_RAY_T_MAX_EXT ) |
| { |
| const std::string raygenShader = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 1) uniform accelerationStructureEXT topLevelAS;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint cullMask = 0xFF;\n" |
| " float a = float(gl_LaunchIDEXT.x) / gl_LaunchSizeEXT.x;\n" |
| " float b = 1.0f + float(gl_LaunchIDEXT.y) / gl_LaunchSizeEXT.y;\n" |
| " float c = 0.25f * a / b;\n" |
| " float tmin = c;\n" |
| " float tmax = 0.75f + c;\n" |
| " vec3 origin = vec3((float(gl_LaunchIDEXT.x) + 0.5f) / float(gl_LaunchSizeEXT.x), (float(gl_LaunchIDEXT.y) + 0.5f) / float(gl_LaunchSizeEXT.y), 0.0);\n" |
| " vec3 direct = vec3(0.0, 0.0, -1.0);\n" |
| " traceRayEXT(topLevelAS, gl_RayFlagsNoneEXT, cullMask, 0, 0, 0, origin, tmin, direct, tmax, 0);\n" |
| "}\n"; |
| const std::string intersectionShader = |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " float a = float(gl_LaunchIDEXT.x) / gl_LaunchSizeEXT.x;\n" |
| " float b = 1.0f + float(gl_LaunchIDEXT.y) / gl_LaunchSizeEXT.y;\n" |
| " float c = 0.25f * a / b;\n" |
| " reportIntersectionEXT(0.03125f + c, 0);\n" |
| "}\n"; |
| const std::string updateImage = |
| " ivec3 p = ivec3(gl_LaunchIDEXT);\n" |
| " int r = int(" +de::toString(FIXED_POINT_DIVISOR) + ".0f * gl_" + std::string(m_data.name) + ");\n" |
| " ivec4 c = ivec4(r,0,0,1);\n" |
| " imageStore(result, p, c);\n"; |
| |
| switch (m_data.stage) |
| { |
| case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "\n" |
| " float a = float(gl_LaunchIDEXT.x) / gl_LaunchSizeEXT.x;\n" |
| " float b = 1.0f + float(gl_LaunchIDEXT.y) / gl_LaunchSizeEXT.y;\n" |
| " reportIntersectionEXT(0.4375f + 0.25f * a / b, 0x7Eu);\n" |
| "}\n"; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_MISS_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(raygenShader)) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(intersectionShader)) << buildOptions; |
| |
| break; |
| } |
| |
| default: |
| TCU_THROW(InternalError, "Unknown stage"); |
| } |
| } |
| else if (m_data.id == TEST_ID_WORLD_RAY_ORIGIN_EXT || |
| m_data.id == TEST_ID_WORLD_RAY_DIRECTION_EXT || |
| m_data.id == TEST_ID_OBJECT_RAY_ORIGIN_EXT || |
| m_data.id == TEST_ID_OBJECT_RAY_DIRECTION_EXT || |
| m_data.id == TEST_ID_OBJECT_TO_WORLD_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT || |
| m_data.id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT ) |
| { |
| const bool matrix4x3 = (m_data.id == TEST_ID_OBJECT_TO_WORLD_EXT || m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT); |
| const bool matrix3x4 = (m_data.id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT || m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT); |
| const bool matrixOutput = matrix4x3 || matrix3x4; |
| const std::string vectorLoop = |
| " for (int ndx = 0; ndx < 3; ndx++)\n" |
| " {\n"; |
| const std::string matrixLoop4x3 = |
| " int ndx = -1;\n" |
| " for (int row = 0; row < 3; row++)\n" |
| " for (int col = 0; col < 4; col++)\n" |
| " {\n" |
| " ndx++;\n"; |
| const std::string matrixLoop3x4 = |
| " int ndx = -1;\n" |
| " for (int col = 0; col < 3; col++)\n" |
| " for (int row = 0; row < 4; row++)\n" |
| " {\n" |
| " ndx++;\n"; |
| const std::string loop = |
| matrix4x3 ? matrixLoop4x3 : |
| matrix3x4 ? matrixLoop3x4 : |
| vectorLoop; |
| const std::string index = |
| (matrixOutput ? "[col][row]" : "[ndx]"); |
| const std::string updateImage = |
| " float k = " +de::toString(FIXED_POINT_DIVISOR) + ".0f;\n" |
| + loop + |
| " ivec3 p = ivec3(gl_LaunchIDEXT.xy, ndx);\n" |
| " float r = k * gl_" + std::string(m_data.name) + index + ";\n" |
| " ivec4 c = ivec4(int(r),0,0,1);\n" |
| " imageStore(result, p, c);\n" |
| " }\n"; |
| |
| switch (m_data.stage) |
| { |
| case VK_SHADER_STAGE_ANY_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(getIntersectionPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n" |
| "hitAttributeEXT vec3 attribs;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(getIntersectionPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_INTERSECTION_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "hitAttributeEXT vec3 hitAttribute;\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| " reportIntersectionEXT(0.95f, 0);\n" |
| "}\n"; |
| |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(getMissPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| case VK_SHADER_STAGE_MISS_BIT_KHR: |
| { |
| programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader())) << buildOptions; |
| |
| { |
| std::stringstream css; |
| css << |
| "#version 460 core\n" |
| "#extension GL_EXT_ray_tracing : require\n" |
| "layout(set = 0, binding = 0, r32i) uniform iimage3D result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| << updateImage << |
| "}\n"; |
| |
| programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())) << buildOptions; |
| } |
| |
| programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(getHitPassthrough())) << buildOptions; |
| |
| if (m_data.geomType == GEOM_TYPE_AABBS) |
| programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(getIntersectionPassthrough())) << buildOptions; |
| |
| break; |
| } |
| |
| default: |
| TCU_THROW(InternalError, "Unknown stage"); |
| } |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| } |
| |
| TestInstance* RayTracingTestCase::createInstance (Context& context) const |
| { |
| return new RayTracingBuiltinLaunchTestInstance(context, m_data); |
| } |
| |
| de::MovePtr<TopLevelAccelerationStructure> RayTracingBuiltinLaunchTestInstance::initTopAccelerationStructure (VkCommandBuffer cmdBuffer, |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> >& bottomLevelAccelerationStructures) |
| { |
| const DeviceInterface& vkd = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| de::MovePtr<TopLevelAccelerationStructure> result = makeTopLevelAccelerationStructure(); |
| const bool transformTest = m_data.id == TEST_ID_WORLD_RAY_ORIGIN_EXT |
| || m_data.id == TEST_ID_WORLD_RAY_DIRECTION_EXT |
| || m_data.id == TEST_ID_OBJECT_RAY_ORIGIN_EXT |
| || m_data.id == TEST_ID_OBJECT_RAY_DIRECTION_EXT |
| || m_data.id == TEST_ID_OBJECT_TO_WORLD_EXT |
| || m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT |
| || m_data.id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT |
| || m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT; |
| |
| result->setInstanceCount(bottomLevelAccelerationStructures.size()); |
| |
| for (size_t structNdx = 0; structNdx < bottomLevelAccelerationStructures.size(); ++structNdx) |
| { |
| VkTransformMatrixKHR transform = identityMatrix3x4; |
| |
| if (transformTest) |
| { |
| if (structNdx & 1) |
| transform.matrix[0][3] = (1.0f / 8.0f) / float(m_data.width); |
| |
| if (structNdx & 2) |
| transform.matrix[1][3] = (1.0f / 16.0f) / float(m_data.height); |
| } |
| |
| result->addInstance(bottomLevelAccelerationStructures[structNdx], transform, deUint32(2 * structNdx)); |
| } |
| |
| result->createAndBuild(vkd, device, cmdBuffer, allocator); |
| |
| return result; |
| } |
| |
| de::MovePtr<BottomLevelAccelerationStructure> RayTracingBuiltinLaunchTestInstance::initBottomAccelerationStructure (VkCommandBuffer cmdBuffer, |
| tcu::UVec2& startPos) |
| { |
| const DeviceInterface& vkd = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| Allocator& allocator = m_context.getDefaultAllocator(); |
| de::MovePtr<BottomLevelAccelerationStructure> result = makeBottomLevelAccelerationStructure(); |
| |
| result->setGeometryCount(m_data.geometriesGroupCount); |
| |
| if (m_data.id == TEST_ID_LAUNCH_ID_EXT || m_data.id == TEST_ID_LAUNCH_SIZE_EXT) |
| { |
| result->setDefaultGeometryData(m_data.stage); |
| } |
| else if (m_data.id == TEST_ID_GEOMETRY_INDEX_EXT || |
| m_data.id == TEST_ID_PRIMITIVE_ID || |
| m_data.id == TEST_ID_INSTANCE_ID || |
| m_data.id == TEST_ID_INSTANCE_CUSTOM_INDEX_EXT ) |
| { |
| const bool triangles = (m_data.geomType == GEOM_TYPE_TRIANGLES); |
| const bool missShader = (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR); |
| const float z = !missShader ? -1.0f : -100.0f; |
| |
| DE_ASSERT(m_data.squaresGroupCount != 1); |
| |
| for (size_t geometryNdx = 0; geometryNdx < m_data.geometriesGroupCount; ++geometryNdx) |
| { |
| std::vector<tcu::Vec3> geometryData; |
| |
| geometryData.reserve(m_data.squaresGroupCount * (triangles ? 3u : 2u)); |
| |
| for (size_t squareNdx = 0; squareNdx < m_data.squaresGroupCount; ++squareNdx) |
| { |
| const deUint32 n = m_data.width * startPos.y() + startPos.x(); |
| const float x0 = float(startPos.x() + 0) / float(m_data.width); |
| const float y0 = float(startPos.y() + 0) / float(m_data.height); |
| const float x1 = float(startPos.x() + 1) / float(m_data.width); |
| const float y1 = float(startPos.y() + 1) / float(m_data.height); |
| const deUint32 m = n + 1; |
| |
| if (triangles) |
| { |
| const float xm = (x0 + x1) / 2.0f; |
| const float ym = (y0 + y1) / 2.0f; |
| |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, y1, z * 0.9f)); |
| } |
| |
| startPos.y() = m / m_data.width; |
| startPos.x() = m % m_data.width; |
| } |
| |
| result->addGeometry(geometryData, triangles); |
| } |
| } |
| else if (m_data.id == TEST_ID_HIT_KIND_EXT) |
| { |
| const bool triangles = (m_data.geomType == GEOM_TYPE_TRIANGLES); |
| const bool missShader = (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR); |
| const float z = !missShader ? -1.0f : -100.0f; |
| |
| DE_ASSERT(m_data.squaresGroupCount != 1); |
| DE_ASSERT(m_data.geometriesGroupCount == 4); |
| |
| std::vector<tcu::Vec3> geometryDataOpaque; |
| std::vector<tcu::Vec3> geometryDataNonOpaque; |
| |
| geometryDataOpaque.reserve(m_data.squaresGroupCount * (triangles ? 3u : 2u)); |
| geometryDataNonOpaque.reserve(m_data.squaresGroupCount * (triangles ? 3u : 2u)); |
| |
| for (size_t geometryNdx = 0; geometryNdx < m_data.geometriesGroupCount; ++geometryNdx) |
| { |
| const bool cw = ((geometryNdx & 1) == 0) ? true : false; |
| std::vector<tcu::Vec3>& geometryData = ((geometryNdx & 2) == 0) ? geometryDataOpaque : geometryDataNonOpaque; |
| |
| for (size_t squareNdx = 0; squareNdx < m_data.squaresGroupCount; ++squareNdx) |
| { |
| const deUint32 n = m_data.width * startPos.y() + startPos.x(); |
| const deUint32 m = n + 1; |
| const float x0 = float(startPos.x() + 0) / float(m_data.width); |
| const float y0 = float(startPos.y() + 0) / float(m_data.height); |
| const float x1 = float(startPos.x() + 1) / float(m_data.width); |
| const float y1 = float(startPos.y() + 1) / float(m_data.height); |
| |
| if (triangles) |
| { |
| const float xm = (x0 + x1) / 2.0f; |
| const float ym = (y0 + y1) / 2.0f; |
| |
| if (cw) |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| } |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, y1, z * 0.9f)); |
| } |
| |
| startPos.y() = m / m_data.width; |
| startPos.x() = m % m_data.width; |
| } |
| } |
| |
| DE_ASSERT(startPos.y() == m_data.height && startPos.x() == 0); |
| |
| result->addGeometry(geometryDataOpaque, triangles, (VkGeometryFlagsKHR)VK_GEOMETRY_OPAQUE_BIT_KHR); |
| result->addGeometry(geometryDataNonOpaque, triangles, (VkGeometryFlagsKHR)0); |
| } |
| else if (m_data.id == TEST_ID_INCOMING_RAY_FLAGS_EXT) |
| { |
| const bool triangles = (m_data.geomType == GEOM_TYPE_TRIANGLES); |
| const bool missShader = (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR); |
| const float z = !missShader ? -1.0f : -100.0f; |
| const VkGeometryFlagsKHR geometryFlags = m_data.opaque ? static_cast<VkGeometryFlagsKHR>(VK_GEOMETRY_OPAQUE_BIT_KHR) : static_cast<VkGeometryFlagsKHR>(0); |
| const bool cw = m_data.frontFace; |
| std::vector<tcu::Vec3> geometryData; |
| |
| DE_ASSERT(m_data.geometriesGroupCount == 1); |
| DE_ASSERT(m_data.squaresGroupCount != 1); |
| |
| geometryData.reserve(m_data.squaresGroupCount * (triangles ? 3u : 2u)); |
| |
| for (size_t squareNdx = 0; squareNdx < m_data.squaresGroupCount; ++squareNdx) |
| { |
| const deUint32 n = m_data.width * startPos.y() + startPos.x(); |
| const deUint32 m = n + 1; |
| const float x0 = float(startPos.x() + 0) / float(m_data.width); |
| const float y0 = float(startPos.y() + 0) / float(m_data.height); |
| const float x1 = float(startPos.x() + 1) / float(m_data.width); |
| const float y1 = float(startPos.y() + 1) / float(m_data.height); |
| |
| if (triangles) |
| { |
| const float xm = (x0 + x1) / 2.0f; |
| const float ym = (y0 + y1) / 2.0f; |
| |
| if (cw) |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| } |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, y1, z * 0.9f)); |
| } |
| |
| startPos.y() = m / m_data.width; |
| startPos.x() = m % m_data.width; |
| } |
| |
| DE_ASSERT(startPos.y() == m_data.height && startPos.x() == 0); |
| |
| result->addGeometry(geometryData, triangles, geometryFlags); |
| } |
| else if (m_data.id == TEST_ID_HIT_T_EXT || |
| m_data.id == TEST_ID_RAY_T_MIN_EXT || |
| m_data.id == TEST_ID_RAY_T_MAX_EXT ) |
| { |
| const bool triangles = (m_data.geomType == GEOM_TYPE_TRIANGLES); |
| const bool missShader = (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR); |
| const bool sectShader = (m_data.stage == VK_SHADER_STAGE_INTERSECTION_BIT_KHR); |
| const bool maxTTest = (m_data.id == TEST_ID_RAY_T_MAX_EXT); |
| |
| DE_ASSERT(m_data.squaresGroupCount != 1); |
| |
| for (size_t geometryNdx = 0; geometryNdx < m_data.geometriesGroupCount; ++geometryNdx) |
| { |
| std::vector<tcu::Vec3> geometryData; |
| |
| geometryData.reserve(m_data.squaresGroupCount * (triangles ? 3u : 2u)); |
| |
| for (size_t squareNdx = 0; squareNdx < m_data.squaresGroupCount; ++squareNdx) |
| { |
| const deUint32 n = m_data.width * startPos.y() + startPos.x(); |
| const deUint32 m = n + 1; |
| const bool shiftRight = sectShader && maxTTest && (0 == (startPos.y() & 1)) && (0 == (startPos.x() & 1)); |
| const deUint32 xo = shiftRight ? 1 : 0; |
| const float x0 = float(startPos.x() + 0 + xo) / float(m_data.width); |
| const float y0 = float(startPos.y() + 0) / float(m_data.height); |
| const float x1 = float(startPos.x() + 1 + xo) / float(m_data.width); |
| const float y1 = float(startPos.y() + 1) / float(m_data.height); |
| const float a = x0; |
| const float b = 1.0f + y0; |
| const float c = 0.03125f + 0.25f * a / b; |
| const float z = !missShader ? -c : -100.0f; |
| |
| if (triangles) |
| { |
| const float xm = (x0 + x1) / 2.0f; |
| const float ym = (y0 + y1) / 2.0f; |
| |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(xm, y1, z)); |
| geometryData.push_back(tcu::Vec3(x1, ym, z)); |
| } |
| else |
| { |
| geometryData.push_back(tcu::Vec3(x0, y0, z)); |
| geometryData.push_back(tcu::Vec3(x1, y1, z * 0.9f)); |
| } |
| |
| startPos.y() = m / m_data.width; |
| startPos.x() = m % m_data.width; |
| } |
| |
| result->addGeometry(geometryData, triangles); |
| } |
| } |
| else if (m_data.id == TEST_ID_WORLD_RAY_ORIGIN_EXT || |
| m_data.id == TEST_ID_WORLD_RAY_DIRECTION_EXT || |
| m_data.id == TEST_ID_OBJECT_RAY_ORIGIN_EXT || |
| m_data.id == TEST_ID_OBJECT_RAY_DIRECTION_EXT || |
| m_data.id == TEST_ID_OBJECT_TO_WORLD_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT || |
| m_data.id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT ) |
| { |
| const bool triangles = m_data.geomType == GEOM_TYPE_TRIANGLES; |
| const float y0 = float(startPos.y() + 0) / float(m_data.height); |
| const float y1 = float(startPos.y() + 1) / float(m_data.height); |
| const bool missShader = (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR); |
| const float z = !missShader ? -1.0f : -100.0f; |
| std::vector<tcu::Vec3> geometryData; |
| |
| if (triangles) |
| { |
| geometryData.push_back(tcu::Vec3(-1.0f, y1, z)); |
| geometryData.push_back(tcu::Vec3(-1.0f, y0, z)); |
| geometryData.push_back(tcu::Vec3(+1.0f, y0, z)); |
| geometryData.push_back(tcu::Vec3(-1.0f, y1, z)); |
| geometryData.push_back(tcu::Vec3(+1.0f, y0, z)); |
| geometryData.push_back(tcu::Vec3(+1.0f, y1, z)); |
| } |
| else |
| { |
| geometryData.reserve(2); |
| |
| geometryData.push_back(tcu::Vec3(-1.0f, y0, z)); |
| geometryData.push_back(tcu::Vec3(+1.0f, y1, z)); |
| } |
| |
| DE_ASSERT(startPos.y() < m_data.height); |
| |
| startPos.y()++; |
| |
| result->addGeometry(geometryData, triangles); |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| |
| result->createAndBuild(vkd, device, cmdBuffer, allocator); |
| |
| return result; |
| } |
| |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> > RayTracingBuiltinLaunchTestInstance::initBottomAccelerationStructures (VkCommandBuffer cmdBuffer) |
| { |
| tcu::UVec2 startPos; |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> > result; |
| |
| for (size_t instanceNdx = 0; instanceNdx < m_data.instancesGroupCount; ++instanceNdx) |
| { |
| de::MovePtr<BottomLevelAccelerationStructure> bottomLevelAccelerationStructure = initBottomAccelerationStructure(cmdBuffer, startPos); |
| |
| result.push_back(de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release())); |
| } |
| |
| return result; |
| } |
| |
| Move<VkPipeline> RayTracingBuiltinLaunchTestInstance::makePipeline (de::MovePtr<RayTracingPipeline>& rayTracingPipeline, |
| VkPipelineLayout pipelineLayout, |
| const VkSpecializationInfo* specializationInfo) |
| { |
| const DeviceInterface& vkd = m_context.getDeviceInterface(); |
| const VkDevice device = m_context.getDevice(); |
| vk::BinaryCollection& collection = m_context.getBinaryCollection(); |
| |
| if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR , createShaderModule(vkd, device, collection.get("rgen"), 0), m_raygenShaderGroup, specializationInfo); |
| if (0 != (m_shaders & VK_SHADER_STAGE_ANY_HIT_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("ahit"), 0), m_hitShaderGroup, specializationInfo); |
| if (0 != (m_shaders & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("chit"), 0), m_hitShaderGroup, specializationInfo); |
| if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR , createShaderModule(vkd, device, collection.get("miss"), 0), m_missShaderGroup, specializationInfo); |
| if (0 != (m_shaders & VK_SHADER_STAGE_INTERSECTION_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR , createShaderModule(vkd, device, collection.get("sect"), 0), m_hitShaderGroup, specializationInfo); |
| if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR)) rayTracingPipeline->addShader(VK_SHADER_STAGE_CALLABLE_BIT_KHR , createShaderModule(vkd, device, collection.get("call"), 0), m_callableShaderGroup, specializationInfo); |
| |
| if (m_data.pipelineCreateFlags != 0) |
| rayTracingPipeline->setCreateFlags(m_data.pipelineCreateFlags); |
| |
| Move<VkPipeline> pipeline = rayTracingPipeline->createPipeline(vkd, device, pipelineLayout); |
| |
| return pipeline; |
| } |
| |
| de::MovePtr<BufferWithMemory> RayTracingBuiltinLaunchTestInstance::createShaderBindingTable (const InstanceInterface& vki, |
| const DeviceInterface& vkd, |
| const VkDevice device, |
| const VkPhysicalDevice physicalDevice, |
| const VkPipeline pipeline, |
| Allocator& allocator, |
| de::MovePtr<RayTracingPipeline>& rayTracingPipeline, |
| const deUint32 group) |
| { |
| de::MovePtr<BufferWithMemory> shaderBindingTable; |
| |
| if (group < m_shaderGroupCount) |
| { |
| const deUint32 shaderGroupHandleSize = getShaderGroupSize(vki, physicalDevice); |
| const deUint32 shaderGroupBaseAlignment = getShaderGroupBaseAlignment(vki, physicalDevice); |
| |
| shaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, group, 1u); |
| } |
| |
| return shaderBindingTable; |
| } |
| |
| // Provides two spec constants, one integer and one float, both with value 256. |
| class SpecConstantsHelper |
| { |
| public: |
| SpecConstantsHelper (); |
| const VkSpecializationInfo& getSpecializationInfo (void) const; |
| private: |
| std::vector<deUint8> m_data; |
| std::vector<VkSpecializationMapEntry> m_mapEntries; |
| VkSpecializationInfo m_specInfo; |
| }; |
| |
| SpecConstantsHelper::SpecConstantsHelper () |
| : m_data () |
| , m_mapEntries () |
| { |
| // To make things interesting, make both data unaligned and add some padding. |
| const deInt32 value1 = 256; |
| const float value2 = 256.0f; |
| |
| const size_t offset1 = 1u; // Offset of 1 byte. |
| const size_t offset2 = 1u + sizeof(value1) + 2u; // Offset of 3 bytes plus the size of value1. |
| |
| m_data.resize(sizeof(value1) + sizeof(value2) + 5u); // Some extra padding at the end too. |
| deMemcpy(&m_data[offset1], &value1, sizeof(value1)); |
| deMemcpy(&m_data[offset2], &value2, sizeof(value2)); |
| |
| // Map entries. |
| m_mapEntries.reserve(2u); |
| m_mapEntries.push_back({ 0u, static_cast<deUint32>(offset1), static_cast<deUintptr>(sizeof(value1)) }); |
| m_mapEntries.push_back({ 1u, static_cast<deUint32>(offset2), static_cast<deUintptr>(sizeof(value2)) }); |
| |
| // Specialization info. |
| m_specInfo.mapEntryCount = static_cast<deUint32>(m_mapEntries.size()); |
| m_specInfo.pMapEntries = m_mapEntries.data(); |
| m_specInfo.dataSize = static_cast<deUintptr>(m_data.size()); |
| m_specInfo.pData = m_data.data(); |
| } |
| |
| const VkSpecializationInfo& SpecConstantsHelper::getSpecializationInfo (void) const |
| { |
| return m_specInfo; |
| } |
| |
| de::MovePtr<BufferWithMemory> RayTracingBuiltinLaunchTestInstance::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 deUint32 shaderGroupHandleSize = getShaderGroupSize(vki, physicalDevice); |
| const VkFormat format = m_data.format; |
| const deUint32 pixelSize = tcu::getPixelSize(mapVkFormat(format)); |
| const deUint32 pixelCount = m_data.width * m_data.height * m_data.depth; |
| |
| const Move<VkDescriptorSetLayout> 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<VkDescriptorPool> 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<VkDescriptorSet> descriptorSet = makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout); |
| const Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vkd, device, descriptorSetLayout.get()); |
| const Move<VkCommandPool> cmdPool = createCommandPool(vkd, device, 0, queueFamilyIndex); |
| const Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); |
| |
| de::MovePtr<RayTracingPipeline> rayTracingPipeline = de::newMovePtr<RayTracingPipeline>(); |
| const SpecConstantsHelper specConstantHelper; |
| const VkSpecializationInfo* specializationInfo = (m_data.useSpecConstants ? &specConstantHelper.getSpecializationInfo() : nullptr); |
| const Move<VkPipeline> pipeline = makePipeline(rayTracingPipeline, *pipelineLayout, specializationInfo); |
| const de::MovePtr<BufferWithMemory> raygenShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *pipeline, allocator, rayTracingPipeline, m_raygenShaderGroup); |
| const de::MovePtr<BufferWithMemory> missShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *pipeline, allocator, rayTracingPipeline, m_missShaderGroup); |
| const de::MovePtr<BufferWithMemory> hitShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *pipeline, allocator, rayTracingPipeline, m_hitShaderGroup); |
| const de::MovePtr<BufferWithMemory> callableShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *pipeline, allocator, rayTracingPipeline, m_callableShaderGroup); |
| |
| const VkStridedDeviceAddressRegionKHR raygenShaderBindingTableRegion = raygenShaderBindingTable.get() != NULL ? makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, raygenShaderBindingTable->get(), 0), shaderGroupHandleSize, shaderGroupHandleSize) : makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0); |
| const VkStridedDeviceAddressRegionKHR missShaderBindingTableRegion = missShaderBindingTable.get() != NULL ? makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, missShaderBindingTable->get(), 0), shaderGroupHandleSize, shaderGroupHandleSize) : makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0); |
| const VkStridedDeviceAddressRegionKHR hitShaderBindingTableRegion = hitShaderBindingTable.get() != NULL ? makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, hitShaderBindingTable->get(), 0), shaderGroupHandleSize, shaderGroupHandleSize) : makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0); |
| const VkStridedDeviceAddressRegionKHR callableShaderBindingTableRegion = callableShaderBindingTable.get() != NULL ? makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, callableShaderBindingTable->get(), 0), shaderGroupHandleSize, shaderGroupHandleSize) : makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0); |
| |
| const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_data.width, m_data.height, m_data.depth, format); |
| const VkImageSubresourceRange imageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0, 1u); |
| const de::MovePtr<ImageWithMemory> image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any)); |
| const Move<VkImageView> imageView = makeImageView(vkd, device, **image, VK_IMAGE_VIEW_TYPE_3D, format, imageSubresourceRange); |
| |
| const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(pixelCount * pixelSize, 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, m_data.depth), bufferImageSubresourceLayers); |
| de::MovePtr<BufferWithMemory> buffer = de::MovePtr<BufferWithMemory>(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_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, |
| VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, |
| **image, imageSubresourceRange); |
| const VkMemoryBarrier postTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT); |
| const VkMemoryBarrier postCopyMemoryBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT); |
| const VkClearValue clearValue = makeClearValueColorU32(DEFAULT_UINT_CLEAR_VALUE, DEFAULT_UINT_CLEAR_VALUE, DEFAULT_UINT_CLEAR_VALUE, 255u); |
| |
| vector<de::SharedPtr<BottomLevelAccelerationStructure> > bottomLevelAccelerationStructures; |
| de::MovePtr<TopLevelAccelerationStructure> 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, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, &postImageBarrier); |
| |
| bottomLevelAccelerationStructures = initBottomAccelerationStructures(*cmdBuffer); |
| topLevelAccelerationStructure = initTopAccelerationStructure(*cmdBuffer, bottomLevelAccelerationStructures); |
| |
| 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, m_data.raysDepth); |
| |
| cmdPipelineMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, 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(), VK_WHOLE_SIZE); |
| |
| return buffer; |
| } |
| |
| void checkFormatSupported(Context& context, VkFormat format, VkImageUsageFlags usage, const VkExtent3D& extent) |
| { |
| VkResult result; |
| VkImageFormatProperties properties; |
| |
| result = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(), format, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL, usage, 0, &properties); |
| |
| if (result == VK_ERROR_FORMAT_NOT_SUPPORTED) |
| { |
| std::ostringstream msg; |
| |
| msg << "Format " << format << " not supported for usage flags 0x" << std::hex << usage; |
| |
| TCU_THROW(NotSupportedError, msg.str()); |
| } |
| |
| if (properties.maxExtent.width < extent.width || properties.maxExtent.height < extent.height || properties.maxExtent.depth < extent.depth) |
| TCU_THROW(NotSupportedError, "Image size is too large for this format"); |
| |
| VK_CHECK(result); |
| } |
| |
| void RayTracingBuiltinLaunchTestInstance::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(); |
| const de::MovePtr<RayTracingProperties> rayTracingProperties = makeRayTracingProperties(vki, physicalDevice); |
| const VkExtent3D extent = makeExtent3D(m_data.width, m_data.height, m_data.depth); |
| |
| checkFormatSupported(m_context, m_data.format, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, extent); |
| |
| if (rayTracingProperties->getMaxPrimitiveCount() < 2 * 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"); |
| } |
| |
| std::vector<deInt32> RayTracingBuiltinLaunchTestInstance::expectedIntValuesBuffer (void) |
| { |
| deUint32 pos = 0; |
| std::vector<deInt32> result; |
| |
| result.reserve(m_data.depth * m_data.height * m_data.width); |
| |
| if (m_data.id == TEST_ID_LAUNCH_ID_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result.push_back(deInt32(x + 256 * (y + 256 * z)) + 1); |
| } |
| else if (m_data.id == TEST_ID_LAUNCH_SIZE_EXT) |
| { |
| const deUint32 expectedValue = m_data.width + 256 * (m_data.height + 256 * m_data.depth); |
| const std::vector<deInt32> result2 (m_data.depth * m_data.height * m_data.width, deInt32(expectedValue) + 1); |
| |
| result = result2; |
| } |
| else if (m_data.id == TEST_ID_GEOMETRY_INDEX_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result.push_back(deInt32((pos++ / m_data.squaresGroupCount) % m_data.geometriesGroupCount)); |
| } |
| else if (m_data.id == TEST_ID_PRIMITIVE_ID) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result.push_back(deInt32(pos++ % m_data.squaresGroupCount)); |
| } |
| else if (m_data.id == TEST_ID_INSTANCE_ID) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result.push_back(deInt32(pos++ / (m_data.squaresGroupCount * m_data.geometriesGroupCount))); |
| } |
| else if (m_data.id == TEST_ID_INSTANCE_CUSTOM_INDEX_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result.push_back(deInt32(2 * (pos++ / (m_data.squaresGroupCount * m_data.geometriesGroupCount)))); |
| } |
| else if (m_data.id == TEST_ID_INCOMING_RAY_FLAGS_EXT) |
| { |
| DE_ASSERT(m_data.squaresGroupCount == (1<<RAY_FLAG_BIT_LAST_PER_TEST)); |
| DE_ASSERT(DEFAULT_UINT_CLEAR_VALUE != (1<<RAY_FLAG_BIT_LAST_PER_TEST)); |
| |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const deUint32 n = x + m_data.width * (y + m_data.height * z); |
| const bool rayOpaque = (0 != (n & (1<<RAY_FLAG_BIT_OPAQUE_EXT ))); |
| const bool rayNoOpaque = (0 != (n & (1<<RAY_FLAG_BIT_NO_OPAQUE_EXT ))) && !rayOpaque; |
| const bool rayTerminateOnFirstHit = (0 != (n & (1<<RAY_FLAG_BIT_TERMINATE_ON_FIRST_HIT_EXT ))); |
| const bool raySkipClosestHitShader = (0 != (n & (1<<RAY_FLAG_BIT_SKIP_CLOSEST_HIT_SHADER_EXT ))); |
| const bool rayCullBack = (0 != (n & (1<<RAY_FLAG_BIT_CULL_BACK_FACING_TRIANGLES_EXT ))); |
| const bool rayCullFront = (0 != (n & (1<<RAY_FLAG_BIT_CULL_FRONT_FACING_TRIANGLES_EXT))) && !rayCullBack; |
| const bool rayCullOpaque = (0 != (n & (1<<RAY_FLAG_BIT_CULL_OPAQUE_EXT ))) && !rayOpaque && !rayNoOpaque; |
| const bool rayCullNoOpaque = (0 != (n & (1<<RAY_FLAG_BIT_CULL_NO_OPAQUE_EXT ))) && !rayOpaque && !rayNoOpaque && !rayCullOpaque; |
| const bool raySkipTriangles = m_data.rayFlagSkipTriangles; |
| const bool raySkipAABBs = m_data.rayFlagSkipAABSs; |
| const bool pipelineSkipTriangles = (m_data.pipelineCreateFlags & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) != 0; |
| const bool pipelineSkipAABBs = (m_data.pipelineCreateFlags & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR) != 0; |
| const bool cullingTest = m_data.rayFlagSkipTriangles || m_data.rayFlagSkipAABSs || pipelineSkipTriangles || pipelineSkipAABBs; |
| const bool geometryFrontFace = m_data.frontFace; |
| const bool geometryOpaque = m_data.opaque; |
| const bool geometryTriangles = (m_data.geomType == GEOM_TYPE_TRIANGLES) ? true : false; |
| const bool geometryAABBs = (m_data.geomType == GEOM_TYPE_AABBS) ? true : false; |
| deUint32 v = 0 |
| | (rayOpaque ? (1<<RAY_FLAG_BIT_OPAQUE_EXT ) : 0) |
| | (rayNoOpaque ? (1<<RAY_FLAG_BIT_NO_OPAQUE_EXT ) : 0) |
| | (rayTerminateOnFirstHit ? (1<<RAY_FLAG_BIT_TERMINATE_ON_FIRST_HIT_EXT ) : 0) |
| | (raySkipClosestHitShader ? (1<<RAY_FLAG_BIT_SKIP_CLOSEST_HIT_SHADER_EXT ) : 0) |
| | (rayCullBack ? (1<<RAY_FLAG_BIT_CULL_BACK_FACING_TRIANGLES_EXT ) : 0) |
| | (rayCullFront ? (1<<RAY_FLAG_BIT_CULL_FRONT_FACING_TRIANGLES_EXT) : 0) |
| | (rayCullOpaque ? (1<<RAY_FLAG_BIT_CULL_OPAQUE_EXT ) : 0) |
| | (rayCullNoOpaque ? (1<<RAY_FLAG_BIT_CULL_NO_OPAQUE_EXT ) : 0) |
| | (raySkipTriangles ? (1<<RAY_FLAG_BIT_SKIP_TRIANGLES_EXT ) : 0) |
| | (raySkipAABBs ? (1<<RAY_FLAG_BIT_SKIP_AABB_EXT ) : 0); |
| |
| if (m_data.stage == VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR && raySkipClosestHitShader) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| |
| if (m_data.stage == VK_SHADER_STAGE_ANY_HIT_BIT_KHR && (rayOpaque || (geometryOpaque && !rayOpaque && !rayNoOpaque))) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| |
| if (geometryOpaque) |
| { |
| if (rayCullOpaque) |
| if (m_data.stage != VK_SHADER_STAGE_MISS_BIT_KHR) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| else |
| { |
| if (rayCullNoOpaque) |
| if (m_data.stage != VK_SHADER_STAGE_MISS_BIT_KHR) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| |
| if (geometryTriangles) |
| { |
| if (geometryFrontFace) |
| { |
| if (rayCullFront) |
| if (m_data.stage != VK_SHADER_STAGE_MISS_BIT_KHR) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| else |
| { |
| if (rayCullBack) |
| if (m_data.stage != VK_SHADER_STAGE_MISS_BIT_KHR) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| } |
| |
| if (cullingTest) |
| { |
| if (m_data.stage != VK_SHADER_STAGE_MISS_BIT_KHR) |
| { |
| if (geometryTriangles) |
| { |
| if (raySkipTriangles || pipelineSkipTriangles) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| |
| if (geometryAABBs) |
| { |
| if (raySkipAABBs || pipelineSkipAABBs) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| } |
| } |
| } |
| |
| result.push_back(deInt32(v)); |
| } |
| } |
| else if (m_data.id == TEST_ID_HIT_KIND_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const deUint32 n = x + m_data.width * (y + m_data.height * z); |
| const deUint32 geometryNdx = n / m_data.squaresGroupCount; |
| const deUint32 hitKind = ((geometryNdx & 1) == 0) ? 0xFEu : 0xFFu; |
| const bool geometryOpaque = ((geometryNdx & 2) == 0) ? true : false; |
| deUint32 v = (m_data.geomType == GEOM_TYPE_TRIANGLES) ? hitKind : 0x7Eu; |
| |
| if (m_data.stage == VK_SHADER_STAGE_ANY_HIT_BIT_KHR && geometryOpaque) |
| v = DEFAULT_UINT_CLEAR_VALUE; |
| |
| result.push_back(deInt32(v)); |
| } |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| |
| return result; |
| } |
| |
| std::vector<float> RayTracingBuiltinLaunchTestInstance::expectedFloatValuesBuffer (void) |
| { |
| std::vector<float> result; |
| |
| result.reserve(m_data.depth * m_data.height * m_data.width); |
| |
| if (m_data.id == TEST_ID_HIT_T_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float a = float(x) / float(m_data.width); |
| const float b = 1.0f + float(y) / float(m_data.height); |
| const float f = 0.03125f + 0.25f * a / b; |
| |
| result.push_back(f); |
| } |
| } |
| else if (m_data.id == TEST_ID_RAY_T_MIN_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float a = float(x) / float(m_data.width); |
| const float b = 1.0f + float(y) / float(m_data.height); |
| const float f = 0.25f * a / b; |
| |
| result.push_back(f); |
| } |
| } |
| else if (m_data.id == TEST_ID_RAY_T_MAX_EXT) |
| { |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float a = float(x) / float(m_data.width); |
| const float b = 1.0f + float(y) / float(m_data.height); |
| const float c = 0.25f * a / b; |
| // In a miss shader, the value is identical to the parameter passed into traceRayEXT(). |
| const float m = 0.75f + c; |
| // In the closest-hit shader, the value reflects the closest distance to the intersected primitive. |
| // In the any-hit shader, it reflects the distance to the primitive currently being intersected. |
| // In the intersection shader, it reflects the distance to the closest primitive intersected so far. |
| const float n = 0.03125f + c; |
| const bool normalRow = (y & 1) != 0; |
| const bool doublePrimitive = (x & 1) != 0; |
| const float s = normalRow ? m |
| : doublePrimitive ? 0.4375f + c |
| : float(DEFAULT_UINT_CLEAR_VALUE) / float(FIXED_POINT_DIVISOR); |
| const float f = (m_data.stage == VK_SHADER_STAGE_INTERSECTION_BIT_KHR) ? s |
| : (m_data.stage == VK_SHADER_STAGE_MISS_BIT_KHR) ? m |
| : n; |
| |
| result.push_back(f); |
| } |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| |
| return result; |
| } |
| |
| std::vector<float> RayTracingBuiltinLaunchTestInstance::expectedVectorValuesBuffer (void) |
| { |
| const deUint32 imageDepth = 4; |
| const deUint32 expectedFloats = imageDepth * m_data.height * m_data.width; |
| std::vector<float> result (expectedFloats, float(DEFAULT_UINT_CLEAR_VALUE) / float(FIXED_POINT_DIVISOR)); |
| |
| if (m_data.id == TEST_ID_WORLD_RAY_ORIGIN_EXT) |
| { |
| deUint32 pos = 0; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = (0.5f + float(x)) / float(m_data.width); |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = (0.5f + float(y)) / float(m_data.height); |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| } |
| else if (m_data.id == TEST_ID_WORLD_RAY_DIRECTION_EXT) |
| { |
| deUint32 pos = 0; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = -1.0f; |
| } |
| else if (m_data.id == TEST_ID_OBJECT_RAY_ORIGIN_EXT) |
| { |
| deUint32 pos = 0; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const deUint32 instanceId = y / (m_data.height / m_data.instancesGroupCount); |
| const float offset = (instanceId & 1) ? 1.0f / 8.0f : 0.0f; |
| |
| result[pos++] = (0.5f + float(x) - offset) / float(m_data.width); |
| } |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const deUint32 instanceId = y / (m_data.height / m_data.instancesGroupCount); |
| const float offset = (instanceId & 2) ? 1.0f / 16.0f : 0.0f; |
| |
| result[pos++] = (0.5f + float(y) - offset) / float(m_data.height); |
| } |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| } |
| else if (m_data.id == TEST_ID_OBJECT_RAY_DIRECTION_EXT) |
| { |
| deUint32 pos = 0; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = 0.0f; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| result[pos++] = -1.0f; |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| |
| return result; |
| } |
| |
| std::vector<float> RayTracingBuiltinLaunchTestInstance::expectedMatrixValuesBuffer (void) |
| { |
| const deUint32 colCount = 4; |
| const deUint32 rowCount = 3; |
| const deUint32 imageDepth = 4 * 4; |
| const deUint32 zStride = m_data.height * m_data.width; |
| const deUint32 expectedFloats = imageDepth * m_data.height * m_data.width; |
| std::vector<float> result (expectedFloats, float(DEFAULT_UINT_CLEAR_VALUE) / float(FIXED_POINT_DIVISOR)); |
| |
| if (m_data.id == TEST_ID_OBJECT_TO_WORLD_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT || |
| m_data.id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT || |
| m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT) |
| { |
| const int translateColumnNumber = 3; |
| const float translateSign = (m_data.id == TEST_ID_WORLD_TO_OBJECT_EXT || m_data.id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT) ? -1.0f : +1.0f; |
| const float translateX = translateSign * (1.0f / 8.0f) / float(m_data.width); |
| const float translateY = translateSign * (1.0f / 16.0f) / float(m_data.height); |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| { |
| const deUint32 instanceId = y / (m_data.height / m_data.instancesGroupCount); |
| |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| tcu::Matrix<float, rowCount, colCount> m; |
| const deUint32 elem0Pos = x + m_data.width * y; |
| |
| if (instanceId & 1) |
| m[translateColumnNumber][0] = translateX; |
| |
| if (instanceId & 2) |
| m[translateColumnNumber][1] = translateY; |
| |
| for (deUint32 rowNdx = 0; rowNdx < rowCount; ++rowNdx) |
| for (deUint32 colNdx = 0; colNdx < colCount; ++colNdx) |
| { |
| const deUint32 z = rowNdx * colCount + colNdx; |
| const deUint32 pos = elem0Pos + zStride * z; |
| |
| result[pos] = m[colNdx][rowNdx]; |
| } |
| } |
| } |
| } |
| else |
| { |
| TCU_THROW(InternalError, "Not implemented"); |
| } |
| |
| return result; |
| } |
| |
| bool RayTracingBuiltinLaunchTestInstance::validateIntBuffer (de::MovePtr<BufferWithMemory> buffer) |
| { |
| const deInt32* bufferPtr = (deInt32*)buffer->getAllocation().getHostPtr(); |
| const vector<deInt32> expectedValues = expectedIntValuesBuffer(); |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| deUint32 failures = 0; |
| deUint32 pos = 0; |
| |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| if (bufferPtr[pos] != expectedValues[pos]) |
| failures++; |
| |
| ++pos; |
| } |
| |
| if (failures != 0) |
| { |
| const char * names[] = { "Retrieved:", "Expected:" }; |
| for (deUint32 n = 0; n < 2; ++n) |
| { |
| const deInt32* loggedData = (n == 0) ? bufferPtr : expectedValues.data(); |
| std::stringstream css; |
| |
| pos = 0; |
| |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| { |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| if (bufferPtr[pos] == expectedValues[pos]) |
| css << "____,"; |
| else |
| css << std::hex << std::setw(4) << loggedData[pos] << ","; |
| |
| pos++; |
| } |
| |
| css << std::endl; |
| } |
| |
| log << tcu::TestLog::Message << names[n] << tcu::TestLog::EndMessage; |
| log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage; |
| } |
| } |
| |
| return failures == 0; |
| } |
| |
| bool RayTracingBuiltinLaunchTestInstance::validateFloatBuffer (de::MovePtr<BufferWithMemory> buffer) |
| { |
| const float eps = float(FIXED_POINT_ALLOWED_ERROR) / float(FIXED_POINT_DIVISOR); |
| const deInt32* bufferPtr = (deInt32*)buffer->getAllocation().getHostPtr(); |
| const vector<float> expectedValues = expectedFloatValuesBuffer(); |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| deUint32 failures = 0; |
| deUint32 pos = 0; |
| |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| |
| if (deFloatAbs(retrievedValue - expectedValues[pos]) > eps) |
| failures++; |
| |
| ++pos; |
| } |
| |
| if (failures != 0) |
| { |
| const char * names[] = { "Retrieved:", "Expected:" }; |
| |
| for (deUint32 n = 0; n < 2; ++n) |
| { |
| std::stringstream css; |
| |
| pos = 0; |
| |
| for (deUint32 z = 0; z < m_data.depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| { |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| const float expectedValue = expectedValues[pos]; |
| |
| if (deFloatAbs(retrievedValue - expectedValue) > eps) |
| css << std::setprecision(8) << std::setw(12) << (n == 0 ? retrievedValue : expectedValue) << ","; |
| else |
| css << "____________,"; |
| |
| pos++; |
| } |
| |
| css << std::endl; |
| } |
| |
| log << tcu::TestLog::Message << names[n] << tcu::TestLog::EndMessage; |
| log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage; |
| } |
| } |
| |
| return failures == 0; |
| } |
| |
| bool RayTracingBuiltinLaunchTestInstance::validateVectorBuffer (de::MovePtr<BufferWithMemory> buffer) |
| { |
| const float eps = float(FIXED_POINT_ALLOWED_ERROR) / float(FIXED_POINT_DIVISOR); |
| const deInt32* bufferPtr = (deInt32*)buffer->getAllocation().getHostPtr(); |
| const vector<float> expectedValues = expectedVectorValuesBuffer(); |
| const deUint32 depth = 3u; // vec3 |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| deUint32 failures = 0; |
| deUint32 pos = 0; |
| |
| DE_ASSERT(depth <= m_data.depth); |
| |
| for (deUint32 z = 0; z < depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| |
| if (deFloatAbs(retrievedValue - expectedValues[pos]) > eps) |
| failures++; |
| |
| ++pos; |
| } |
| |
| if (failures != 0) |
| { |
| const char* names[] = { "Retrieved", "Expected " }; |
| std::stringstream css; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| { |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| for (deUint32 n = 0; n < 2; ++n) |
| { |
| css << names[n] << " at (" << x << "," << y << ") {"; |
| |
| for (deUint32 z = 0; z < depth; ++z) |
| { |
| pos = x + m_data.width * (y + m_data.height * z); |
| |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| const float expectedValue = expectedValues[pos]; |
| |
| if (deFloatAbs(retrievedValue - expectedValue) > eps) |
| css << std::setprecision(8) << std::setw(12) << (n == 0 ? retrievedValue : expectedValue) << ","; |
| else |
| css << "____________,"; |
| } |
| |
| css << "}" << std::endl; |
| } |
| } |
| } |
| |
| log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage; |
| } |
| |
| return failures == 0; |
| } |
| |
| bool RayTracingBuiltinLaunchTestInstance::validateMatrixBuffer (de::MovePtr<BufferWithMemory> buffer) |
| { |
| const float eps = float(FIXED_POINT_ALLOWED_ERROR) / float(FIXED_POINT_DIVISOR); |
| const deInt32* bufferPtr = (deInt32*)buffer->getAllocation().getHostPtr(); |
| const vector<float> expectedValues = expectedMatrixValuesBuffer(); |
| const deUint32 depth = 12u; // mat3x4 or mat4x3 |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| deUint32 failures = 0; |
| deUint32 pos = 0; |
| |
| DE_ASSERT(depth <= m_data.depth); |
| |
| for (deUint32 z = 0; z < depth; ++z) |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| |
| if (deFloatAbs(retrievedValue - expectedValues[pos]) > eps) |
| failures++; |
| |
| ++pos; |
| } |
| |
| if (failures != 0) |
| { |
| const char* names[] = { "Retrieved", "Expected" }; |
| std::stringstream css; |
| |
| for (deUint32 y = 0; y < m_data.height; ++y) |
| { |
| for (deUint32 x = 0; x < m_data.width; ++x) |
| { |
| css << "At (" << x << "," << y << ")" << std::endl; |
| for (deUint32 n = 0; n < 2; ++n) |
| { |
| css << names[n] << std::endl << "{" << std::endl; |
| |
| for (deUint32 z = 0; z < depth; ++z) |
| { |
| pos = x + m_data.width * (y + m_data.height * z); |
| |
| const float retrievedValue = float(bufferPtr[pos]) / float(FIXED_POINT_DIVISOR); |
| const float expectedValue = expectedValues[pos]; |
| |
| if (z % 4 == 0) |
| css << " {"; |
| |
| if (deFloatAbs(retrievedValue - expectedValue) > eps) |
| css << std::setprecision(5) << std::setw(9) << (n == 0 ? retrievedValue : expectedValue) << ","; |
| else |
| css << "_________,"; |
| |
| if (z % 4 == 3) |
| css << "}" << std::endl; |
| } |
| |
| css << "}" << std::endl; |
| } |
| } |
| } |
| |
| log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage; |
| } |
| |
| return failures == 0; |
| } |
| |
| tcu::TestStatus RayTracingBuiltinLaunchTestInstance::iterate (void) |
| { |
| checkSupportInInstance(); |
| |
| de::MovePtr<BufferWithMemory> buffer = runTest(); |
| const bool ok = m_data.fixedPointMatrixOutput ? validateMatrixBuffer(buffer) |
| : m_data.fixedPointVectorOutput ? validateVectorBuffer(buffer) |
| : m_data.fixedPointScalarOutput ? validateFloatBuffer(buffer) |
| : validateIntBuffer(buffer); |
| |
| if (ok) |
| return tcu::TestStatus::pass("pass"); |
| else |
| return tcu::TestStatus::fail("fail"); |
| } |
| |
| static const struct Stages |
| { |
| const char* name; |
| VkShaderStageFlagBits stage; |
| } |
| stages[] |
| { |
| { "rgen", VK_SHADER_STAGE_RAYGEN_BIT_KHR }, |
| { "ahit", VK_SHADER_STAGE_ANY_HIT_BIT_KHR }, |
| { "chit", VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR }, |
| { "sect", VK_SHADER_STAGE_INTERSECTION_BIT_KHR }, |
| { "miss", VK_SHADER_STAGE_MISS_BIT_KHR }, |
| { "call", VK_SHADER_STAGE_CALLABLE_BIT_KHR }, |
| }; |
| |
| static const struct GeomTypes |
| { |
| const char* name; |
| GeomType geomType; |
| } |
| geomTypes[] = |
| { |
| { "triangles", GEOM_TYPE_TRIANGLES }, |
| { "aabs", GEOM_TYPE_AABBS }, |
| }; |
| |
| void createLaunchTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* builtinGroup, TestId id, const char* name, const VkShaderStageFlags shaderStageFlags) |
| { |
| const struct |
| { |
| deUint32 width; |
| deUint32 height; |
| deUint32 depth; |
| } |
| sizes[] = |
| { |
| { 1, 1, 1 }, |
| { 16, 16, 16 }, |
| { 256, 256, 1 }, |
| { 16384, 1, 1 }, |
| { 1, 16384, 1 }, |
| { 1, 1, 16384 }, |
| { 128, 128, 128 }, |
| { 2048, 4096, 1 }, |
| { 317, 3331, 1 }, |
| { 1, 1331, 111 }, |
| }; |
| |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, de::toLower(name).c_str(), "")); |
| |
| for (size_t stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) |
| { |
| if ((shaderStageFlags & stages[stageNdx].stage) == 0) |
| continue; |
| |
| for (size_t sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx) |
| { |
| const deUint32 width = sizes[sizeNdx].width; |
| const deUint32 height = sizes[sizeNdx].height; |
| const deUint32 depth = sizes[sizeNdx].depth; |
| const bool plain = isPlain(width, height, depth); |
| const deUint32 k = (plain ? 1 : 6); |
| const deUint32 largestGroup = k * width * height * depth; |
| const deUint32 squaresGroupCount = largestGroup; |
| const deUint32 geometriesGroupCount = 1; |
| const deUint32 instancesGroupCount = 1; |
| const CaseDef caseDef = |
| { |
| id, // TestId id; |
| name, // const char* name; |
| width, // deUint32 width; |
| height, // deUint32 height; |
| depth, // deUint32 depth; |
| depth, // deUint32 raysDepth; |
| VK_FORMAT_R32_SINT, // VkFormat format; |
| false, // bool fixedPointScalarOutput; |
| false, // bool fixedPointVectorOutput; |
| false, // bool fixedPointMatrixOutput; |
| GEOM_TYPE_TRIANGLES, // GeomType geomType; |
| squaresGroupCount, // deUint32 squaresGroupCount; |
| geometriesGroupCount, // deUint32 geometriesGroupCount; |
| instancesGroupCount, // deUint32 instancesGroupCount; |
| stages[stageNdx].stage, // VkShaderStageFlagBits stage; |
| false, // bool skipTriangles; |
| false, // bool skipAABSs; |
| false, // bool opaque; |
| false, // bool frontFace; |
| 0u, // VkPipelineCreateFlags pipelineCreateFlags; |
| false, // bool useSpecConstants; |
| }; |
| const std::string suffix = de::toString(caseDef.width) + '_' + de::toString(caseDef.height) + '_' + de::toString(caseDef.depth); |
| const std::string testName = string(stages[stageNdx].name) + '_' + suffix; |
| |
| group->addChild(new RayTracingTestCase(testCtx, testName.c_str(), "", caseDef)); |
| } |
| } |
| |
| builtinGroup->addChild(group.release()); |
| } |
| |
| void createScalarTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* builtinGroup, TestId id, const char* name, const VkShaderStageFlags shaderStageFlags) |
| { |
| const struct |
| { |
| deUint32 width; |
| deUint32 height; |
| TestId id; |
| } |
| sizes[] = |
| { |
| { 16, 16, TEST_ID_HIT_KIND_EXT }, |
| { 16, 16, TEST_ID_HIT_T_EXT }, |
| { 16, 16, TEST_ID_RAY_T_MIN_EXT }, |
| { 16, 16, TEST_ID_RAY_T_MAX_EXT }, |
| { 32, 32, TEST_ID_LAST }, |
| { 64, 64, TEST_ID_LAST }, |
| { 256, 256, TEST_ID_LAST }, |
| }; |
| const bool fourGeometryGroups = id == TEST_ID_HIT_KIND_EXT |
| || id == TEST_ID_HIT_T_EXT |
| || id == TEST_ID_RAY_T_MIN_EXT |
| || id == TEST_ID_RAY_T_MAX_EXT; |
| const bool fixedPointScalarOutput = id == TEST_ID_HIT_T_EXT |
| || id == TEST_ID_RAY_T_MIN_EXT |
| || id == TEST_ID_RAY_T_MAX_EXT; |
| const deUint32 imageDepth = 1; |
| const deUint32 rayDepth = 1; |
| |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, de::toLower(name).c_str(), "")); |
| |
| for (size_t geomTypesNdx = 0; geomTypesNdx < DE_LENGTH_OF_ARRAY(geomTypes); ++geomTypesNdx) |
| for (size_t stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) |
| { |
| const GeomType geomType = geomTypes[geomTypesNdx].geomType; |
| |
| if ((shaderStageFlags & stages[stageNdx].stage) == 0) |
| continue; |
| |
| if (stages[stageNdx].stage == VK_SHADER_STAGE_INTERSECTION_BIT_KHR && geomTypes[geomTypesNdx].geomType == GEOM_TYPE_TRIANGLES) |
| continue; |
| |
| bool testAdded = false; |
| bool generalTestsStarted = false; |
| |
| for (size_t sizesNdx = 0; sizesNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizesNdx) |
| { |
| const bool specializedTest = (sizes[sizesNdx].id != TEST_ID_LAST); |
| const deUint32 width = sizes[sizesNdx].width; |
| const deUint32 height = sizes[sizesNdx].height; |
| const deUint32 instancesGroupCount = fourGeometryGroups ? 1 : 4; |
| const deUint32 geometriesGroupCount = fourGeometryGroups ? 4 : 8; |
| const deUint32 largestGroup = width * height / geometriesGroupCount / instancesGroupCount; |
| const deUint32 squaresGroupCount = largestGroup; |
| const CaseDef caseDef = |
| { |
| id, // TestId id; |
| name, // const char* name; |
| width, // deUint32 width; |
| height, // deUint32 height; |
| imageDepth, // deUint32 depth; |
| rayDepth, // deUint32 raysDepth; |
| VK_FORMAT_R32_SINT, // VkFormat format; |
| fixedPointScalarOutput, // bool fixedPointScalarOutput; |
| false, // bool fixedPointVectorOutput; |
| false, // bool fixedPointMatrixOutput; |
| geomType, // GeomType geomType; |
| squaresGroupCount, // deUint32 squaresGroupCount; |
| geometriesGroupCount, // deUint32 geometriesGroupCount; |
| instancesGroupCount, // deUint32 instancesGroupCount; |
| stages[stageNdx].stage, // VkShaderStageFlagBits stage; |
| false, // bool skipTriangles; |
| false, // bool skipAABSs; |
| false, // bool opaque; |
| false, // bool frontFace; |
| 0u, // VkPipelineCreateFlags pipelineCreateFlags; |
| false, // bool useSpecConstants; |
| }; |
| const std::string suffix = '_' + de::toString(caseDef.width) + '_' + de::toString(caseDef.height); |
| const std::string testName = string(stages[stageNdx].name) + '_' + geomTypes[geomTypesNdx].name + (specializedTest ? "" : suffix); |
| |
| if (specializedTest) |
| { |
| DE_UNREF(generalTestsStarted); |
| DE_ASSERT(!generalTestsStarted); |
| |
| if (sizes[sizesNdx].id != id) |
| continue; |
| } |
| else |
| { |
| generalTestsStarted = true; |
| } |
| |
| group->addChild(new RayTracingTestCase(testCtx, testName.c_str(), "", caseDef)); |
| testAdded = true; |
| |
| if (specializedTest) |
| break; |
| } |
| |
| DE_ASSERT(testAdded); |
| DE_UNREF(testAdded); |
| } |
| |
| builtinGroup->addChild(group.release()); |
| } |
| |
| void createRayFlagsTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* builtinGroup, TestId id, const char* name, const VkShaderStageFlags shaderStageFlags) |
| { |
| const deUint32 width = 16; |
| const deUint32 height = 16; |
| const deUint32 imageDepth = 1; |
| const deUint32 rayDepth = 1; |
| |
| const struct Opaques |
| { |
| const char* name; |
| bool flag; |
| } |
| opaques[] = |
| { |
| { "opaque", true }, |
| { "noopaque", false }, |
| }; |
| const struct Faces |
| { |
| const char* name; |
| bool flag; |
| } |
| faces[] = |
| { |
| { "frontface", true }, |
| { "backface", false }, |
| }; |
| const struct SkipRayFlags |
| { |
| const char* name; |
| bool skipTriangles; |
| bool skipAABBs; |
| } |
| skipRayFlags[] = |
| { |
| { "raynoskipflags", false, false }, |
| { "rayskiptriangles", true, false }, |
| { "rayskipaabbs", false, true }, |
| }; |
| const struct PipelineFlags |
| { |
| const char* name; |
| VkPipelineCreateFlags flag; |
| } |
| pipelineFlags[] = |
| { |
| { "pipelinenoskipflags", static_cast<VkPipelineCreateFlags>(0) }, |
| { "pipelineskiptriangles", VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR }, |
| { "pipelineskipaabbs", VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR }, |
| }; |
| |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, de::toLower(name).c_str(), "")); |
| |
| for (size_t geomTypesNdx = 0; geomTypesNdx < DE_LENGTH_OF_ARRAY(geomTypes); ++geomTypesNdx) |
| { |
| const GeomType geomType = geomTypes[geomTypesNdx].geomType; |
| de::MovePtr<tcu::TestCaseGroup> geomGroup (new tcu::TestCaseGroup(testCtx, geomTypes[geomTypesNdx].name, "")); |
| |
| for (size_t skipRayFlagsNdx = 0; skipRayFlagsNdx < DE_LENGTH_OF_ARRAY(skipRayFlags); ++skipRayFlagsNdx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> rayFlagsGroup (new tcu::TestCaseGroup(testCtx, skipRayFlags[skipRayFlagsNdx].name, "")); |
| |
| for (size_t pipelineFlagsNdx = 0; pipelineFlagsNdx < DE_LENGTH_OF_ARRAY(pipelineFlags); ++pipelineFlagsNdx) |
| { |
| const bool skipTriangles = (skipRayFlags[skipRayFlagsNdx].skipTriangles || (pipelineFlags[pipelineFlagsNdx].flag & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR)); |
| const bool skipAABBs = (skipRayFlags[skipRayFlagsNdx].skipAABBs || (pipelineFlags[pipelineFlagsNdx].flag & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR)); |
| |
| // Skipping both triangles and AABBs is not legal according to the spec. |
| if (skipTriangles && skipAABBs) |
| continue; |
| |
| de::MovePtr<tcu::TestCaseGroup> pipelineFlagsGroup (new tcu::TestCaseGroup(testCtx, pipelineFlags[pipelineFlagsNdx].name, "")); |
| |
| for (size_t opaquesNdx = 0; opaquesNdx < DE_LENGTH_OF_ARRAY(opaques); ++opaquesNdx) |
| for (size_t facesNdx = 0; facesNdx < DE_LENGTH_OF_ARRAY(faces); ++facesNdx) |
| { |
| const std::string geomPropertiesGroupName = string(opaques[opaquesNdx].name) + '_' + string(faces[facesNdx].name); |
| de::MovePtr<tcu::TestCaseGroup> geomPropertiesGroup (new tcu::TestCaseGroup(testCtx, geomPropertiesGroupName.c_str(), "")); |
| |
| for (size_t stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) |
| { |
| if ((shaderStageFlags & stages[stageNdx].stage) == 0) |
| continue; |
| |
| if (stages[stageNdx].stage == VK_SHADER_STAGE_INTERSECTION_BIT_KHR && geomTypes[geomTypesNdx].geomType == GEOM_TYPE_TRIANGLES) |
| continue; |
| |
| const deUint32 instancesGroupCount = 1; |
| const deUint32 geometriesGroupCount = 1; |
| const deUint32 largestGroup = width * height / geometriesGroupCount / instancesGroupCount; |
| const deUint32 squaresGroupCount = largestGroup; |
| const CaseDef caseDef = |
| { |
| id, // TestId id; |
| name, // const char* name; |
| width, // deUint32 width; |
| height, // deUint32 height; |
| imageDepth, // deUint32 depth; |
| rayDepth, // deUint32 raysDepth; |
| VK_FORMAT_R32_SINT, // VkFormat format; |
| false, // bool fixedPointScalarOutput; |
| false, // bool fixedPointVectorOutput; |
| false, // bool fixedPointMatrixOutput; |
| geomType, // GeomType geomType; |
| squaresGroupCount, // deUint32 squaresGroupCount; |
| geometriesGroupCount, // deUint32 geometriesGroupCount; |
| instancesGroupCount, // deUint32 instancesGroupCount; |
| stages[stageNdx].stage, // VkShaderStageFlagBits stage; |
| skipRayFlags[skipRayFlagsNdx].skipTriangles, // bool skipTriangles; |
| skipRayFlags[skipRayFlagsNdx].skipAABBs, // bool skipAABSs; |
| opaques[opaquesNdx].flag, // bool opaque; |
| faces[facesNdx].flag, // bool frontFace; |
| pipelineFlags[pipelineFlagsNdx].flag, // VkPipelineCreateFlags pipelineCreateFlags; |
| false, // bool useSpecConstants; |
| }; |
| const std::string testName = string(stages[stageNdx].name) ; |
| |
| geomPropertiesGroup->addChild(new RayTracingTestCase(testCtx, testName.c_str(), "", caseDef)); |
| } |
| |
| pipelineFlagsGroup->addChild(geomPropertiesGroup.release()); |
| } |
| |
| rayFlagsGroup->addChild(pipelineFlagsGroup.release()); |
| } |
| |
| geomGroup->addChild(rayFlagsGroup.release()); |
| } |
| |
| group->addChild(geomGroup.release()); |
| } |
| |
| builtinGroup->addChild(group.release()); |
| } |
| |
| void createMultiOutputTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* builtinGroup, TestId id, const char* name, const VkShaderStageFlags shaderStageFlags) |
| { |
| const bool fixedPointVectorOutput = id == TEST_ID_WORLD_RAY_ORIGIN_EXT |
| || id == TEST_ID_WORLD_RAY_DIRECTION_EXT |
| || id == TEST_ID_OBJECT_RAY_ORIGIN_EXT |
| || id == TEST_ID_OBJECT_RAY_DIRECTION_EXT; |
| const bool fixedPointMatrixOutput = id == TEST_ID_OBJECT_TO_WORLD_EXT |
| || id == TEST_ID_WORLD_TO_OBJECT_EXT |
| || id == TEST_ID_OBJECT_TO_WORLD_3X4_EXT |
| || id == TEST_ID_WORLD_TO_OBJECT_3X4_EXT; |
| const deUint32 imageDepth = fixedPointMatrixOutput ? 4 * 4 |
| : fixedPointVectorOutput ? 4 |
| : 0; |
| const deUint32 rayDepth = 1; |
| |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, de::toLower(name).c_str(), "")); |
| |
| DE_ASSERT(imageDepth != 0); |
| |
| for (size_t geomTypesNdx = 0; geomTypesNdx < DE_LENGTH_OF_ARRAY(geomTypes); ++geomTypesNdx) |
| for (size_t stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) |
| { |
| const GeomType geomType = geomTypes[geomTypesNdx].geomType; |
| |
| if ((shaderStageFlags & stages[stageNdx].stage) == 0) |
| continue; |
| |
| if (stages[stageNdx].stage == VK_SHADER_STAGE_INTERSECTION_BIT_KHR && geomTypes[geomTypesNdx].geomType == GEOM_TYPE_TRIANGLES) |
| continue; |
| |
| const deUint32 width = 4; |
| const deUint32 height = 4; |
| const deUint32 instancesGroupCount = 4; |
| const deUint32 geometriesGroupCount = 1; |
| const deUint32 largestGroup = width * height / geometriesGroupCount / instancesGroupCount; |
| const deUint32 squaresGroupCount = largestGroup; |
| const CaseDef caseDef = |
| { |
| id, // TestId id; |
| name, // const char* name; |
| width, // deUint32 width; |
| height, // deUint32 height; |
| imageDepth, // deUint32 depth; |
| rayDepth, // deUint32 raysDepth; |
| VK_FORMAT_R32_SINT, // VkFormat format; |
| false, // bool fixedPointScalarOutput; |
| fixedPointVectorOutput, // bool fixedPointVectorOutput; |
| fixedPointMatrixOutput, // bool fixedPointMatrixOutput; |
| geomType, // GeomType geomType; |
| squaresGroupCount, // deUint32 squaresGroupCount; |
| geometriesGroupCount, // deUint32 geometriesGroupCount; |
| instancesGroupCount, // deUint32 instancesGroupCount; |
| stages[stageNdx].stage, // VkShaderStageFlagBits stage; |
| false, // bool rayFlagSkipTriangles; |
| false, // bool rayFlagSkipAABSs; |
| false, // bool opaque; |
| false, // bool frontFace; |
| 0u, // VkPipelineCreateFlags pipelineCreateFlags; |
| false, // bool useSpecConstants; |
| }; |
| const std::string testName = string(stages[stageNdx].name) + '_' + geomTypes[geomTypesNdx].name; |
| |
| group->addChild(new RayTracingTestCase(testCtx, testName.c_str(), "", caseDef)); |
| } |
| |
| builtinGroup->addChild(group.release()); |
| } |
| } // anonymous |
| |
| tcu::TestCaseGroup* createBuiltinTests (tcu::TestContext& testCtx) |
| { |
| typedef void CreateBuiltinTestsFunc (tcu::TestContext& testCtx, tcu::TestCaseGroup* group, TestId id, const char* name, const VkShaderStageFlags); |
| |
| const VkShaderStageFlagBits R = VK_SHADER_STAGE_RAYGEN_BIT_KHR; |
| const VkShaderStageFlagBits A = VK_SHADER_STAGE_ANY_HIT_BIT_KHR; |
| const VkShaderStageFlagBits C = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR; |
| const VkShaderStageFlagBits M = VK_SHADER_STAGE_MISS_BIT_KHR; |
| const VkShaderStageFlagBits I = VK_SHADER_STAGE_INTERSECTION_BIT_KHR; |
| const VkShaderStageFlagBits L = VK_SHADER_STAGE_CALLABLE_BIT_KHR; |
| |
| const struct |
| { |
| TestId id; |
| const char* name; |
| VkShaderStageFlags stages; |
| CreateBuiltinTestsFunc* createBuiltinTestsFunc; |
| } |
| tests[] = |
| { |
| { TEST_ID_LAUNCH_ID_EXT, "LaunchIDEXT" , R | A | C | I | M | L , createLaunchTests }, |
| { TEST_ID_LAUNCH_SIZE_EXT, "LaunchSizeEXT" , R | A | C | I | M | L , createLaunchTests }, |
| { TEST_ID_PRIMITIVE_ID, "PrimitiveID" , A | C | I , createScalarTests }, |
| { TEST_ID_INSTANCE_ID, "InstanceID" , A | C | I , createScalarTests }, |
| { TEST_ID_INSTANCE_CUSTOM_INDEX_EXT, "InstanceCustomIndexEXT", A | C | I , createScalarTests }, |
| { TEST_ID_GEOMETRY_INDEX_EXT, "GeometryIndexEXT" , A | C | I , createScalarTests }, |
| { TEST_ID_WORLD_RAY_ORIGIN_EXT, "WorldRayOriginEXT" , A | C | I | M , createMultiOutputTests }, |
| { TEST_ID_WORLD_RAY_DIRECTION_EXT, "WorldRayDirectionEXT" , A | C | I | M , createMultiOutputTests }, |
| { TEST_ID_OBJECT_RAY_ORIGIN_EXT, "ObjectRayOriginEXT" , A | C | I , createMultiOutputTests }, |
| { TEST_ID_OBJECT_RAY_DIRECTION_EXT, "ObjectRayDirectionEXT" , A | C | I , createMultiOutputTests }, |
| { TEST_ID_RAY_T_MIN_EXT, "RayTminEXT" , A | C | I | M , createScalarTests }, |
| { TEST_ID_RAY_T_MAX_EXT, "RayTmaxEXT" , A | C | I | M , createScalarTests }, |
| { TEST_ID_INCOMING_RAY_FLAGS_EXT, "IncomingRayFlagsEXT" , A | C | I | M , createRayFlagsTests }, |
| { TEST_ID_HIT_T_EXT, "HitTEXT" , A | C , createScalarTests }, |
| { TEST_ID_HIT_KIND_EXT, "HitKindEXT" , A | C , createScalarTests }, |
| { TEST_ID_OBJECT_TO_WORLD_EXT, "ObjectToWorldEXT" , A | C | I , createMultiOutputTests }, |
| { TEST_ID_WORLD_TO_OBJECT_EXT, "WorldToObjectEXT" , A | C | I , createMultiOutputTests }, |
| { TEST_ID_OBJECT_TO_WORLD_3X4_EXT, "ObjectToWorld3x4EXT" , A | C | I , createMultiOutputTests }, |
| { TEST_ID_WORLD_TO_OBJECT_3X4_EXT, "WorldToObject3x4EXT" , A | C | I , createMultiOutputTests }, |
| }; |
| |
| de::MovePtr<tcu::TestCaseGroup> builtinGroup(new tcu::TestCaseGroup(testCtx, "builtin", "Ray tracing shader builtin tests")); |
| |
| for (size_t testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(tests); ++testNdx) |
| tests[testNdx].createBuiltinTestsFunc(testCtx, builtinGroup.get(), tests[testNdx].id, tests[testNdx].name, tests[testNdx].stages); |
| |
| return builtinGroup.release(); |
| } |
| |
| tcu::TestCaseGroup* createSpecConstantTests (tcu::TestContext& testCtx) |
| { |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "spec_constants", "Test using spec constants in ray tracing shader stages")); |
| |
| const VkShaderStageFlags stageFlags = 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; |
| const deUint32 width = 256u; |
| const deUint32 height = 256u; |
| const deUint32 depth = 1u; |
| const bool plain = isPlain(width, height, depth); |
| const deUint32 k = (plain ? 1 : 6); |
| const deUint32 largestGroup = k * width * height * depth; |
| const deUint32 squaresGroupCount = largestGroup; |
| const deUint32 geometriesGroupCount = 1; |
| const deUint32 instancesGroupCount = 1; |
| |
| for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) |
| { |
| if ((stageFlags & stages[stageNdx].stage) == 0) |
| continue; |
| |
| const CaseDef caseDef = |
| { |
| TEST_ID_LAUNCH_ID_EXT, // TestId id; |
| "LaunchIDEXT", // const char* name; |
| width, // deUint32 width; |
| height, // deUint32 height; |
| depth, // deUint32 depth; |
| depth, // deUint32 raysDepth; |
| VK_FORMAT_R32_SINT, // VkFormat format; |
| false, // bool fixedPointScalarOutput; |
| false, // bool fixedPointVectorOutput; |
| false, // bool fixedPointMatrixOutput; |
| GEOM_TYPE_TRIANGLES, // GeomType geomType; |
| squaresGroupCount, // deUint32 squaresGroupCount; |
| geometriesGroupCount, // deUint32 geometriesGroupCount; |
| instancesGroupCount, // deUint32 instancesGroupCount; |
| stages[stageNdx].stage, // VkShaderStageFlagBits stage; |
| false, // bool skipTriangles; |
| false, // bool skipAABSs; |
| false, // bool opaque; |
| false, // bool frontFace; |
| 0u, // VkPipelineCreateFlags pipelineCreateFlags; |
| true, // bool useSpecConstants; |
| }; |
| |
| group->addChild(new RayTracingTestCase(testCtx, stages[stageNdx].name, "", caseDef)); |
| } |
| |
| return group.release(); |
| } |
| |
| } // RayTracing |
| } // vkt |
