blob: 1f865ccb3c513be71de0647116992020e9745573 [file] [log] [blame]
/*------------------------------------------------------------------------
* 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 Testing traversal control in ray tracing shaders
*//*--------------------------------------------------------------------*/
#include "vktRayTracingTraversalControlTests.hpp"
#include "vkDefs.hpp"
#include "vktTestCase.hpp"
#include "vktTestGroupUtil.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 "deRandom.hpp"
#include "tcuTexture.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuImageCompare.hpp"
#include "vkRayTracingUtil.hpp"
namespace vkt
{
namespace RayTracing
{
namespace
{
using namespace vk;
using namespace vkt;
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 HitShaderTestType
{
HSTT_ISECT_REPORT_INTERSECTION = 0,
HSTT_ISECT_DONT_REPORT_INTERSECTION = 1,
HSTT_AHIT_PASS_THROUGH = 2,
HSTT_AHIT_IGNORE_INTERSECTION = 3,
HSTT_AHIT_TERMINATE_RAY = 4,
HSTT_COUNT
};
enum BottomTestType
{
BTT_TRIANGLES,
BTT_AABBS
};
const uint32_t TEST_WIDTH = 8;
const uint32_t TEST_HEIGHT = 8;
struct TestParams;
class TestConfiguration
{
public:
virtual ~TestConfiguration()
{
}
virtual std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> initBottomAccelerationStructures(
Context &context, TestParams &testParams) = 0;
virtual de::MovePtr<TopLevelAccelerationStructure> initTopAccelerationStructure(
Context &context, TestParams &testParams,
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> &bottomLevelAccelerationStructures) = 0;
virtual void initRayTracingShaders(de::MovePtr<RayTracingPipeline> &rayTracingPipeline, Context &context,
TestParams &testParams) = 0;
virtual void initShaderBindingTables(de::MovePtr<RayTracingPipeline> &rayTracingPipeline, Context &context,
TestParams &testParams, VkPipeline pipeline, uint32_t shaderGroupHandleSize,
uint32_t shaderGroupBaseAlignment,
de::MovePtr<BufferWithMemory> &raygenShaderBindingTable,
de::MovePtr<BufferWithMemory> &hitShaderBindingTable,
de::MovePtr<BufferWithMemory> &missShaderBindingTable,
de::MovePtr<BufferWithMemory> &callableShaderBindingTable,
VkStridedDeviceAddressRegionKHR &raygenShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &hitShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &missShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &callableShaderBindingTableRegion) = 0;
virtual bool verifyImage(BufferWithMemory *resultBuffer, Context &context, TestParams &testParams) = 0;
virtual VkFormat getResultImageFormat() = 0;
virtual size_t getResultImageFormatSize() = 0;
virtual VkClearValue getClearValue() = 0;
};
struct TestParams
{
uint32_t width;
uint32_t height;
HitShaderTestType hitShaderTestType;
BottomTestType bottomType;
de::SharedPtr<TestConfiguration> testConfiguration;
};
uint32_t getShaderGroupHandleSize(const InstanceInterface &vki, const VkPhysicalDevice physicalDevice)
{
de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
return rayTracingPropertiesKHR->getShaderGroupHandleSize();
}
uint32_t getShaderGroupBaseAlignment(const InstanceInterface &vki, const VkPhysicalDevice physicalDevice)
{
de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
return rayTracingPropertiesKHR->getShaderGroupBaseAlignment();
}
VkImageCreateInfo makeImageCreateInfo(uint32_t width, uint32_t height, uint32_t depth, VkFormat format)
{
const VkImageCreateInfo imageCreateInfo = {
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
nullptr, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_3D, // VkImageType imageType;
format, // VkFormat format;
makeExtent3D(width, height, depth), // VkExtent3D extent;
1u, // uint32_t mipLevels;
1u, // uint32_t arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
0u, // uint32_t queueFamilyIndexCount;
nullptr, // const uint32_t* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
return imageCreateInfo;
}
class SingleSquareConfiguration : public TestConfiguration
{
public:
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> initBottomAccelerationStructures(
Context &context, TestParams &testParams) override;
de::MovePtr<TopLevelAccelerationStructure> initTopAccelerationStructure(
Context &context, TestParams &testParams,
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> &bottomLevelAccelerationStructures) override;
void initRayTracingShaders(de::MovePtr<RayTracingPipeline> &rayTracingPipeline, Context &context,
TestParams &testParams) override;
void initShaderBindingTables(de::MovePtr<RayTracingPipeline> &rayTracingPipeline, Context &context,
TestParams &testParams, VkPipeline pipeline, uint32_t shaderGroupHandleSize,
uint32_t shaderGroupBaseAlignment,
de::MovePtr<BufferWithMemory> &raygenShaderBindingTable,
de::MovePtr<BufferWithMemory> &hitShaderBindingTable,
de::MovePtr<BufferWithMemory> &missShaderBindingTable,
de::MovePtr<BufferWithMemory> &callableShaderBindingTable,
VkStridedDeviceAddressRegionKHR &raygenShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &hitShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &missShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &callableShaderBindingTableRegion) override;
bool verifyImage(BufferWithMemory *resultBuffer, Context &context, TestParams &testParams) override;
VkFormat getResultImageFormat() override;
size_t getResultImageFormatSize() override;
VkClearValue getClearValue() override;
};
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> SingleSquareConfiguration::
initBottomAccelerationStructures(Context &context, TestParams &testParams)
{
DE_UNREF(context);
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> result;
de::MovePtr<BottomLevelAccelerationStructure> bottomLevelAccelerationStructure =
makeBottomLevelAccelerationStructure();
bottomLevelAccelerationStructure->setGeometryCount(1);
de::SharedPtr<RaytracedGeometryBase> geometry;
if (testParams.bottomType == BTT_TRIANGLES)
{
tcu::Vec3 v0(1.0f, float(testParams.height) - 1.0f, 0.0f);
tcu::Vec3 v1(1.0f, 1.0f, 0.0f);
tcu::Vec3 v2(float(testParams.width) - 1.0f, float(testParams.height) - 1.0f, 0.0f);
tcu::Vec3 v3(float(testParams.width) - 1.0f, 1.0f, 0.0f);
geometry =
makeRaytracedGeometry(VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_FORMAT_R32G32B32_SFLOAT, VK_INDEX_TYPE_NONE_KHR);
geometry->addVertex(v0);
geometry->addVertex(v1);
geometry->addVertex(v2);
geometry->addVertex(v2);
geometry->addVertex(v1);
geometry->addVertex(v3);
}
else // testParams.bottomType != BTT_TRIANGLES
{
tcu::Vec3 v0(1.0f, 1.0f, -0.1f);
tcu::Vec3 v1(float(testParams.width) - 1.0f, float(testParams.height) - 1.0f, 0.1f);
geometry =
makeRaytracedGeometry(VK_GEOMETRY_TYPE_AABBS_KHR, VK_FORMAT_R32G32B32_SFLOAT, VK_INDEX_TYPE_NONE_KHR);
geometry->addVertex(v0);
geometry->addVertex(v1);
}
bottomLevelAccelerationStructure->addGeometry(geometry);
result.push_back(de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release()));
return result;
}
de::MovePtr<TopLevelAccelerationStructure> SingleSquareConfiguration::initTopAccelerationStructure(
Context &context, TestParams &testParams,
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> &bottomLevelAccelerationStructures)
{
DE_UNREF(context);
DE_UNREF(testParams);
de::MovePtr<TopLevelAccelerationStructure> result = makeTopLevelAccelerationStructure();
result->setInstanceCount(1);
result->addInstance(bottomLevelAccelerationStructures[0]);
return result;
}
void SingleSquareConfiguration::initRayTracingShaders(de::MovePtr<RayTracingPipeline> &rayTracingPipeline,
Context &context, TestParams &testParams)
{
const DeviceInterface &vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
const std::vector<std::vector<std::string>> shaderNames = {
{"rgen", "isect_report", "ahit", "chit", "miss"},
{"rgen", "isect_pass_through", "ahit", "chit", "miss"},
{"rgen", "isect_report", "ahit_pass_through", "chit", "miss"},
{"rgen", "isect_report", "ahit_ignore", "chit", "miss"},
{"rgen", "isect_report", "ahit_terminate", "chit", "miss"},
};
rayTracingPipeline->addShader(
VK_SHADER_STAGE_RAYGEN_BIT_KHR,
createShaderModule(vkd, device, context.getBinaryCollection().get(shaderNames[testParams.hitShaderTestType][0]),
0),
0);
if (testParams.bottomType == BTT_AABBS)
rayTracingPipeline->addShader(
VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
createShaderModule(vkd, device,
context.getBinaryCollection().get(shaderNames[testParams.hitShaderTestType][1]), 0),
1);
rayTracingPipeline->addShader(
VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
createShaderModule(vkd, device, context.getBinaryCollection().get(shaderNames[testParams.hitShaderTestType][2]),
0),
1);
rayTracingPipeline->addShader(
VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
createShaderModule(vkd, device, context.getBinaryCollection().get(shaderNames[testParams.hitShaderTestType][3]),
0),
1);
rayTracingPipeline->addShader(
VK_SHADER_STAGE_MISS_BIT_KHR,
createShaderModule(vkd, device, context.getBinaryCollection().get(shaderNames[testParams.hitShaderTestType][4]),
0),
2);
}
void SingleSquareConfiguration::initShaderBindingTables(
de::MovePtr<RayTracingPipeline> &rayTracingPipeline, Context &context, TestParams &testParams, VkPipeline pipeline,
uint32_t shaderGroupHandleSize, uint32_t shaderGroupBaseAlignment,
de::MovePtr<BufferWithMemory> &raygenShaderBindingTable, de::MovePtr<BufferWithMemory> &hitShaderBindingTable,
de::MovePtr<BufferWithMemory> &missShaderBindingTable, de::MovePtr<BufferWithMemory> &callableShaderBindingTable,
VkStridedDeviceAddressRegionKHR &raygenShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &hitShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &missShaderBindingTableRegion,
VkStridedDeviceAddressRegionKHR &callableShaderBindingTableRegion)
{
DE_UNREF(testParams);
DE_UNREF(callableShaderBindingTable);
const DeviceInterface &vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
Allocator &allocator = context.getDefaultAllocator();
raygenShaderBindingTable = rayTracingPipeline->createShaderBindingTable(
vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, 0, 1);
hitShaderBindingTable = rayTracingPipeline->createShaderBindingTable(
vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, 1, 1);
missShaderBindingTable = rayTracingPipeline->createShaderBindingTable(
vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, 2, 1);
raygenShaderBindingTableRegion =
makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, raygenShaderBindingTable->get(), 0),
shaderGroupHandleSize, shaderGroupHandleSize);
hitShaderBindingTableRegion =
makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, hitShaderBindingTable->get(), 0),
shaderGroupHandleSize, shaderGroupHandleSize);
missShaderBindingTableRegion =
makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, missShaderBindingTable->get(), 0),
shaderGroupHandleSize, shaderGroupHandleSize);
callableShaderBindingTableRegion = makeStridedDeviceAddressRegionKHR(0, 0, 0);
}
bool SingleSquareConfiguration::verifyImage(BufferWithMemory *resultBuffer, Context &context, TestParams &testParams)
{
// create result image
tcu::TextureFormat imageFormat = vk::mapVkFormat(getResultImageFormat());
tcu::ConstPixelBufferAccess resultAccess(imageFormat, testParams.width, testParams.height, 2,
resultBuffer->getAllocation().getHostPtr());
// create reference image
std::vector<uint32_t> reference(testParams.width * testParams.height * 2);
tcu::PixelBufferAccess referenceAccess(imageFormat, testParams.width, testParams.height, 2, reference.data());
// clear reference image with hit and miss values
// Reference image has two layers:
// - ahit shader writes results to layer 0
// - chit shader writes results to layer 1
// - miss shader writes results to layer 0
// - rays that missed on layer 0 - should have value 0 on layer 1
tcu::UVec4 missValue0 = tcu::UVec4(4, 0, 0, 0);
tcu::UVec4 missValue1 = tcu::UVec4(0, 0, 0, 0);
tcu::UVec4 hitValue0, hitValue1;
switch (testParams.hitShaderTestType)
{
case HSTT_ISECT_REPORT_INTERSECTION:
hitValue0 = tcu::UVec4(1, 0, 0, 0); // ahit returns 1
hitValue1 = tcu::UVec4(3, 0, 0, 0); // chit returns 3
break;
case HSTT_ISECT_DONT_REPORT_INTERSECTION:
hitValue0 = missValue0; // no ahit - results should report miss value
hitValue1 = missValue1; // no chit - results should report miss value
break;
case HSTT_AHIT_PASS_THROUGH:
hitValue0 = tcu::UVec4(0, 0, 0, 0); // empty ahit shader. Initial value from rgen written to result
hitValue1 = tcu::UVec4(3, 0, 0, 0); // chit returns 3
break;
case HSTT_AHIT_IGNORE_INTERSECTION:
hitValue0 = missValue0; // ahit ignores intersection - results should report miss value
hitValue1 = missValue1; // no chit - results should report miss value
break;
case HSTT_AHIT_TERMINATE_RAY:
hitValue0 = tcu::UVec4(
1, 0, 0, 0); // ahit should return 1. If it returned 2, then terminateRayEXT did not terminate ahit shader
hitValue1 = tcu::UVec4(3, 0, 0, 0); // chit returns 3
break;
default:
TCU_THROW(InternalError, "Wrong shader test type");
}
tcu::clear(referenceAccess, missValue0);
for (uint32_t y = 0; y < testParams.width; ++y)
for (uint32_t x = 0; x < testParams.height; ++x)
referenceAccess.setPixel(missValue1, x, y, 1);
for (uint32_t y = 1; y < testParams.width - 1; ++y)
for (uint32_t x = 1; x < testParams.height - 1; ++x)
{
referenceAccess.setPixel(hitValue0, x, y, 0);
referenceAccess.setPixel(hitValue1, x, y, 1);
}
// compare result and reference
return tcu::intThresholdCompare(context.getTestContext().getLog(), "Result comparison", "", referenceAccess,
resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_RESULT);
}
VkFormat SingleSquareConfiguration::getResultImageFormat()
{
return VK_FORMAT_R32_UINT;
}
size_t SingleSquareConfiguration::getResultImageFormatSize()
{
return sizeof(uint32_t);
}
VkClearValue SingleSquareConfiguration::getClearValue()
{
return makeClearValueColorU32(0xFF, 0u, 0u, 0u);
}
class TraversalControlTestCase : public TestCase
{
public:
TraversalControlTestCase(tcu::TestContext &context, const char *name, const TestParams data);
~TraversalControlTestCase(void);
virtual void checkSupport(Context &context) const;
virtual void initPrograms(SourceCollections &programCollection) const;
virtual TestInstance *createInstance(Context &context) const;
private:
TestParams m_data;
};
class TraversalControlTestInstance : public TestInstance
{
public:
TraversalControlTestInstance(Context &context, const TestParams &data);
~TraversalControlTestInstance(void);
tcu::TestStatus iterate(void);
protected:
de::MovePtr<BufferWithMemory> runTest();
private:
TestParams m_data;
};
TraversalControlTestCase::TraversalControlTestCase(tcu::TestContext &context, const char *name, const TestParams data)
: vkt::TestCase(context, name)
, m_data(data)
{
}
TraversalControlTestCase::~TraversalControlTestCase(void)
{
}
void TraversalControlTestCase::checkSupport(Context &context) const
{
context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &rayTracingPipelineFeaturesKHR =
context.getRayTracingPipelineFeatures();
if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == false)
TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
const VkPhysicalDeviceAccelerationStructureFeaturesKHR &accelerationStructureFeaturesKHR =
context.getAccelerationStructureFeatures();
if (accelerationStructureFeaturesKHR.accelerationStructure == false)
TCU_THROW(TestError, "VK_KHR_ray_tracing_pipeline requires "
"VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure");
}
void TraversalControlTestCase::initPrograms(SourceCollections &programCollection) const
{
const vk::ShaderBuildOptions buildOptions(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadEXT uvec4 hitValue;\n"
"layout(r32ui, set = 0, binding = 0) uniform uimage3D result;\n"
"layout(set = 0, binding = 1) uniform accelerationStructureEXT topLevelAS;\n"
"\n"
"void main()\n"
"{\n"
" float tmin = 0.0;\n"
" float tmax = 1.0;\n"
" vec3 origin = vec3(float(gl_LaunchIDEXT.x) + 0.5f, float(gl_LaunchIDEXT.y) + 0.5f, 0.5f);\n"
" vec3 direct = vec3(0.0, 0.0, -1.0);\n"
" hitValue = uvec4(0,0,0,0);\n"
" traceRayEXT(topLevelAS, 0, 0xFF, 0, 0, 0, origin, tmin, direct, tmax, 0);\n"
" imageStore(result, ivec3(gl_LaunchIDEXT.xy, 0), uvec4(hitValue.x, 0, 0, 0));\n"
" imageStore(result, ivec3(gl_LaunchIDEXT.xy, 1), uvec4(hitValue.y, 0, 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"
"hitAttributeEXT uvec4 hitAttribute;\n"
"void main()\n"
"{\n"
" hitAttribute = uvec4(0,0,0,0);\n"
" reportIntersectionEXT(0.5f, 0);\n"
"}\n";
programCollection.glslSources.add("isect_report")
<< glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"void main()\n"
"{\n"
"}\n";
programCollection.glslSources.add("isect_pass_through")
<< glu::IntersectionSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadInEXT uvec4 hitValue;\n"
"void main()\n"
"{\n"
" hitValue.x = 1;\n"
"}\n";
programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"void main()\n"
"{\n"
"}\n";
programCollection.glslSources.add("ahit_pass_through")
<< glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadInEXT uvec4 hitValue;\n"
"void main()\n"
"{\n"
" hitValue.x = 1;\n"
" ignoreIntersectionEXT;\n"
" hitValue.x = 2;\n"
"}\n";
programCollection.glslSources.add("ahit_ignore")
<< glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadInEXT uvec4 hitValue;\n"
"void main()\n"
"{\n"
" hitValue.x = 1;\n"
" terminateRayEXT;\n"
" hitValue.x = 2;\n"
"}\n";
programCollection.glslSources.add("ahit_terminate")
<< glu::AnyHitSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadInEXT uvec4 hitValue;\n"
"void main()\n"
"{\n"
" hitValue.y = 3;\n"
"}\n";
programCollection.glslSources.add("chit")
<< glu::ClosestHitSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
{
std::stringstream css;
css << "#version 460 core\n"
"#extension GL_EXT_ray_tracing : require\n"
"layout(location = 0) rayPayloadInEXT uvec4 hitValue;\n"
"void main()\n"
"{\n"
" hitValue.x = 4;\n"
"}\n";
programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str())) << buildOptions;
}
}
TestInstance *TraversalControlTestCase::createInstance(Context &context) const
{
return new TraversalControlTestInstance(context, m_data);
}
TraversalControlTestInstance::TraversalControlTestInstance(Context &context, const TestParams &data)
: vkt::TestInstance(context)
, m_data(data)
{
}
TraversalControlTestInstance::~TraversalControlTestInstance(void)
{
}
de::MovePtr<BufferWithMemory> TraversalControlTestInstance::runTest()
{
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 uint32_t queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
const VkQueue queue = m_context.getUniversalQueue();
Allocator &allocator = m_context.getDefaultAllocator();
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());
de::MovePtr<RayTracingPipeline> rayTracingPipeline = de::newMovePtr<RayTracingPipeline>();
m_data.testConfiguration->initRayTracingShaders(rayTracingPipeline, m_context, m_data);
Move<VkPipeline> pipeline = rayTracingPipeline->createPipeline(vkd, device, *pipelineLayout);
de::MovePtr<BufferWithMemory> raygenShaderBindingTable;
de::MovePtr<BufferWithMemory> hitShaderBindingTable;
de::MovePtr<BufferWithMemory> missShaderBindingTable;
de::MovePtr<BufferWithMemory> callableShaderBindingTable;
VkStridedDeviceAddressRegionKHR raygenShaderBindingTableRegion;
VkStridedDeviceAddressRegionKHR hitShaderBindingTableRegion;
VkStridedDeviceAddressRegionKHR missShaderBindingTableRegion;
VkStridedDeviceAddressRegionKHR callableShaderBindingTableRegion;
m_data.testConfiguration->initShaderBindingTables(
rayTracingPipeline, m_context, m_data, *pipeline, getShaderGroupHandleSize(vki, physicalDevice),
getShaderGroupBaseAlignment(vki, physicalDevice), raygenShaderBindingTable, hitShaderBindingTable,
missShaderBindingTable, callableShaderBindingTable, raygenShaderBindingTableRegion, hitShaderBindingTableRegion,
missShaderBindingTableRegion, callableShaderBindingTableRegion);
const VkFormat imageFormat = m_data.testConfiguration->getResultImageFormat();
const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_data.width, m_data.height, 2, imageFormat);
const VkImageSubresourceRange imageSubresourceRange =
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 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, imageFormat, imageSubresourceRange);
const VkBufferCreateInfo resultBufferCreateInfo =
makeBufferCreateInfo(m_data.width * m_data.height * 2 * m_data.testConfiguration->getResultImageFormatSize(),
VK_BUFFER_USAGE_TRANSFER_DST_BIT);
const VkImageSubresourceLayers resultBufferImageSubresourceLayers =
makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
const VkBufferImageCopy resultBufferImageRegion =
makeBufferImageCopy(makeExtent3D(m_data.width, m_data.height, 2), resultBufferImageSubresourceLayers);
de::MovePtr<BufferWithMemory> resultBuffer = de::MovePtr<BufferWithMemory>(
new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));
const VkDescriptorImageInfo descriptorImageInfo =
makeDescriptorImageInfo(VK_NULL_HANDLE, *imageView, VK_IMAGE_LAYOUT_GENERAL);
const Move<VkCommandPool> cmdPool = createCommandPool(vkd, device, 0, queueFamilyIndex);
const Move<VkCommandBuffer> cmdBuffer =
allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> bottomLevelAccelerationStructures;
de::MovePtr<TopLevelAccelerationStructure> topLevelAccelerationStructure;
beginCommandBuffer(vkd, *cmdBuffer, 0u);
{
const VkImageMemoryBarrier preImageBarrier =
makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, **image, imageSubresourceRange);
cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, &preImageBarrier);
const VkClearValue clearValue = m_data.testConfiguration->getClearValue();
vkd.cmdClearColorImage(*cmdBuffer, **image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue.color, 1,
&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);
cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, &postImageBarrier);
bottomLevelAccelerationStructures =
m_data.testConfiguration->initBottomAccelerationStructures(m_context, m_data);
for (auto &blas : bottomLevelAccelerationStructures)
blas->createAndBuild(vkd, device, *cmdBuffer, allocator);
topLevelAccelerationStructure = m_data.testConfiguration->initTopAccelerationStructure(
m_context, m_data, bottomLevelAccelerationStructures);
topLevelAccelerationStructure->createAndBuild(vkd, device, *cmdBuffer, allocator);
const TopLevelAccelerationStructure *topLevelAccelerationStructurePtr = topLevelAccelerationStructure.get();
VkWriteDescriptorSetAccelerationStructureKHR accelerationStructureWriteDescriptorSet = {
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, // VkStructureType sType;
nullptr, // const void* pNext;
1u, // uint32_t 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, nullptr);
vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *pipeline);
cmdTraceRays(vkd, *cmdBuffer, &raygenShaderBindingTableRegion, &missShaderBindingTableRegion,
&hitShaderBindingTableRegion, &callableShaderBindingTableRegion, m_data.width, m_data.height, 1);
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);
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, **resultBuffer, 1u,
&resultBufferImageRegion);
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, resultBuffer->getAllocation().getMemory(),
resultBuffer->getAllocation().getOffset(), VK_WHOLE_SIZE);
return resultBuffer;
}
tcu::TestStatus TraversalControlTestInstance::iterate(void)
{
// run test using arrays of pointers
const de::MovePtr<BufferWithMemory> buffer = runTest();
if (!m_data.testConfiguration->verifyImage(buffer.get(), m_context, m_data))
return tcu::TestStatus::fail("Fail");
return tcu::TestStatus::pass("Pass");
}
} // namespace
tcu::TestCaseGroup *createTraversalControlTests(tcu::TestContext &testCtx)
{
// Tests verifying traversal control in RT hit shaders
de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "traversal_control"));
struct HitShaderTestTypeData
{
HitShaderTestType shaderTestType;
bool onlyAabbTest;
const char *name;
} hitShaderTestTypes[] = {
{HSTT_ISECT_REPORT_INTERSECTION, true, "isect_report_intersection"},
{HSTT_ISECT_DONT_REPORT_INTERSECTION, true, "isect_dont_report_intersection"},
{HSTT_AHIT_PASS_THROUGH, false, "ahit_pass_through"},
{HSTT_AHIT_IGNORE_INTERSECTION, false, "ahit_ignore_intersection"},
{HSTT_AHIT_TERMINATE_RAY, false, "ahit_terminate_ray"},
};
struct
{
BottomTestType testType;
const char *name;
} bottomTestTypes[] = {
{BTT_TRIANGLES, "triangles"},
{BTT_AABBS, "aabbs"},
};
for (size_t shaderTestNdx = 0; shaderTestNdx < DE_LENGTH_OF_ARRAY(hitShaderTestTypes); ++shaderTestNdx)
{
de::MovePtr<tcu::TestCaseGroup> testTypeGroup(
new tcu::TestCaseGroup(group->getTestContext(), hitShaderTestTypes[shaderTestNdx].name));
for (size_t testTypeNdx = 0; testTypeNdx < DE_LENGTH_OF_ARRAY(bottomTestTypes); ++testTypeNdx)
{
if (hitShaderTestTypes[shaderTestNdx].onlyAabbTest && bottomTestTypes[testTypeNdx].testType != BTT_AABBS)
continue;
TestParams testParams{TEST_WIDTH, TEST_HEIGHT, hitShaderTestTypes[shaderTestNdx].shaderTestType,
bottomTestTypes[testTypeNdx].testType,
de::SharedPtr<TestConfiguration>(new SingleSquareConfiguration())};
testTypeGroup->addChild(
new TraversalControlTestCase(group->getTestContext(), bottomTestTypes[testTypeNdx].name, testParams));
}
group->addChild(testTypeGroup.release());
}
return group.release();
}
} // namespace RayTracing
} // namespace vkt