external/vulkancts/modules/vulkan/ray_query/vktRayQueryProceduralGeometryTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * 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 Test procedural geometry with complex bouding box sets
  *//*--------------------------------------------------------------------*/

 #include "vktRayQueryProceduralGeometryTests.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 "vkRayTracingUtil.hpp"
 #include "tcuVectorUtil.hpp"
 #include "tcuTexture.hpp"
 #include "tcuTestLog.hpp"
 #include "tcuImageCompare.hpp"
 #include "tcuFloat.hpp"

 namespace vkt
 {
 namespace RayQuery
 {
 namespace
 {
 using namespace vk;
 using namespace vkt;

 enum class TestType
 {
 	OBJECT_BEHIND_BOUNDING_BOX = 0,
 	TRIANGLE_IN_BETWEEN
 };

 class RayQueryProceduralGeometryTestBase : public TestInstance
 {
 public:

 	RayQueryProceduralGeometryTestBase	(Context& context);
 	~RayQueryProceduralGeometryTestBase	(void) = default;

 	tcu::TestStatus iterate				(void) override;

 protected:

 	virtual void setupAccelerationStructures() = 0;

 private:

 	VkWriteDescriptorSetAccelerationStructureKHR	makeASWriteDescriptorSet	(const VkAccelerationStructureKHR* pAccelerationStructure);
 	void											clearBuffer					(de::SharedPtr<BufferWithMemory> buffer, VkDeviceSize bufferSize);

 protected:

 	Move<VkCommandPool>		m_cmdPool;
 	Move<VkCommandBuffer>	m_cmdBuffer;

 	std::vector<de::SharedPtr<BottomLevelAccelerationStructure> >	m_blasVect;
 	de::SharedPtr<TopLevelAccelerationStructure>					m_referenceTLAS;
 	de::SharedPtr<TopLevelAccelerationStructure>					m_resultTLAS;
 };

 RayQueryProceduralGeometryTestBase::RayQueryProceduralGeometryTestBase(Context& context)
 	: vkt::TestInstance	(context)
 	, m_referenceTLAS	(makeTopLevelAccelerationStructure().release())
 	, m_resultTLAS		(makeTopLevelAccelerationStructure().release())
 {
 }

 tcu::TestStatus RayQueryProceduralGeometryTestBase::iterate(void)
 {
 	const DeviceInterface&	vkd					= m_context.getDeviceInterface();
 	const VkDevice			device				= m_context.getDevice();
 	const deUint32			queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
 	const VkQueue			queue				= m_context.getUniversalQueue();
 	Allocator&				allocator			= m_context.getDefaultAllocator();
 	const deUint32			imageSize			= 64u;

 	const Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder()
 		.addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 2u)
 		.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2u)
 		.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 2u);

 	Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
 		.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, VK_SHADER_STAGE_COMPUTE_BIT)	// as with single/four aabb's
 		.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)				// ssbo with result/reference values
 		.build(vkd, device);

 	const Move<VkDescriptorSet>			referenceDescriptorSet	= makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout);
 	const Move<VkDescriptorSet>			resultDescriptorSet		= makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout);

 	const VkDeviceSize					resultBufferSize		= imageSize * imageSize * sizeof(int);
 	const VkBufferCreateInfo			resultBufferCreateInfo	= makeBufferCreateInfo(resultBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
 	de::SharedPtr<BufferWithMemory>		referenceBuffer			= de::SharedPtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));
 	de::SharedPtr<BufferWithMemory>		resultBuffer			= de::SharedPtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));

 	Move<VkShaderModule>				shaderModule		= createShaderModule(vkd, device, m_context.getBinaryCollection().get("comp"), 0u);
 	const Move<VkPipelineLayout>		pipelineLayout		= makePipelineLayout(vkd, device, descriptorSetLayout.get());
 	const VkComputePipelineCreateInfo	pipelineCreateInfo
 	{
 		VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,			// VkStructureType						sType
 		DE_NULL,												// const void*							pNext
 		0u,														// VkPipelineCreateFlags				flags
 		{														// VkPipelineShaderStageCreateInfo		stage
 			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 			DE_NULL,
 			(VkPipelineShaderStageCreateFlags)0,
 			VK_SHADER_STAGE_COMPUTE_BIT,
 			*shaderModule,
 			"main",
 			DE_NULL
 		},
 		*pipelineLayout,										// VkPipelineLayout						layout
 		DE_NULL,												// VkPipeline							basePipelineHandle
 		0,														// deInt32								basePipelineIndex
 	};
 	Move<VkPipeline> pipeline = createComputePipeline(vkd, device, DE_NULL, &pipelineCreateInfo);

 	m_cmdPool	= createCommandPool(vkd, device, 0, queueFamilyIndex);
 	m_cmdBuffer	= allocateCommandBuffer(vkd, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

 	// clear result and reference buffers
 	clearBuffer(resultBuffer, resultBufferSize);
 	clearBuffer(referenceBuffer, resultBufferSize);

 	beginCommandBuffer(vkd, *m_cmdBuffer, 0u);
 	{
 		setupAccelerationStructures();

 		// update descriptor sets
 		{
 			typedef DescriptorSetUpdateBuilder::Location DSL;

 			const VkWriteDescriptorSetAccelerationStructureKHR	referenceAS		= makeASWriteDescriptorSet(m_referenceTLAS->getPtr());
 			const VkDescriptorBufferInfo						referenceSSBO	= makeDescriptorBufferInfo(**referenceBuffer, 0u, VK_WHOLE_SIZE);
 			DescriptorSetUpdateBuilder()
 				.writeSingle(*referenceDescriptorSet, DSL::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &referenceAS)
 				.writeSingle(*referenceDescriptorSet, DSL::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &referenceSSBO)
 				.update(vkd, device);

 			const VkWriteDescriptorSetAccelerationStructureKHR	resultAS	= makeASWriteDescriptorSet(m_resultTLAS->getPtr());
 			const VkDescriptorBufferInfo						resultSSBO	= makeDescriptorBufferInfo(**resultBuffer, 0u, VK_WHOLE_SIZE);
 			DescriptorSetUpdateBuilder()
 				.writeSingle(*resultDescriptorSet, DSL::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &resultAS)
 				.writeSingle(*resultDescriptorSet, DSL::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultSSBO)
 				.update(vkd, device);
 		}

 		// wait for data transfers
 		const VkMemoryBarrier bufferUploadBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT);
 		cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, &bufferUploadBarrier, 1u);

 		// wait for as build
 		const VkMemoryBarrier asBuildBarrier = makeMemoryBarrier(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_SHADER_READ_BIT);
 		cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, &asBuildBarrier, 1u);

 		vkd.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);

 		// generate reference
 		vkd.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, 1, &referenceDescriptorSet.get(), 0, DE_NULL);
 		vkd.cmdDispatch(*m_cmdBuffer, imageSize, imageSize, 1);

 		// generate result
 		vkd.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, 1, &resultDescriptorSet.get(), 0, DE_NULL);
 		vkd.cmdDispatch(*m_cmdBuffer, imageSize, imageSize, 1);

 		const VkMemoryBarrier postTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
 		cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTraceMemoryBarrier);
 	}
 	endCommandBuffer(vkd, *m_cmdBuffer);

 	submitCommandsAndWait(vkd, device, queue, m_cmdBuffer.get());

 	// verify result buffer
 	auto referenceAllocation = referenceBuffer->getAllocation();
 	invalidateMappedMemoryRange(vkd, device, referenceAllocation.getMemory(), referenceAllocation.getOffset(), resultBufferSize);

 	auto resultAllocation = resultBuffer->getAllocation();
 	invalidateMappedMemoryRange(vkd, device, resultAllocation.getMemory(), resultAllocation.getOffset(), resultBufferSize);

 	tcu::TextureFormat		imageFormat		(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
 	tcu::PixelBufferAccess	referenceAccess	(imageFormat, imageSize, imageSize, 1, referenceAllocation.getHostPtr());
 	tcu::PixelBufferAccess	resultAccess	(imageFormat, imageSize, imageSize, 1, resultAllocation.getHostPtr());

 	if (tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Result comparison", "", referenceAccess, resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_EVERYTHING))
 		return tcu::TestStatus::pass("Pass");
 	return tcu::TestStatus::fail("Fail");
 }

 VkWriteDescriptorSetAccelerationStructureKHR RayQueryProceduralGeometryTestBase::makeASWriteDescriptorSet(const VkAccelerationStructureKHR* pAccelerationStructure)
 {
 	return
 	{
 		VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,	// VkStructureType						sType
 		DE_NULL,															// const void*							pNext
 		1u,																	// deUint32								accelerationStructureCount
 		pAccelerationStructure												// const VkAccelerationStructureKHR*	pAccelerationStructures
 	};
 }

 void RayQueryProceduralGeometryTestBase::clearBuffer(de::SharedPtr<BufferWithMemory> buffer, VkDeviceSize bufferSize)
 {
 	const DeviceInterface&	vkd				= m_context.getDeviceInterface();
 	const VkDevice			device			= m_context.getDevice();
 	auto&					bufferAlloc		= buffer->getAllocation();
 	void*					bufferPtr		= bufferAlloc.getHostPtr();

 	deMemset(bufferPtr, 1, static_cast<size_t>(bufferSize));
 	vk::flushAlloc(vkd, device, bufferAlloc);
 }

 class ObjectBehindBoundingBoxInstance : public RayQueryProceduralGeometryTestBase
 {
 public:

 	ObjectBehindBoundingBoxInstance(Context& context);
 	void setupAccelerationStructures() override;
 };

 ObjectBehindBoundingBoxInstance::ObjectBehindBoundingBoxInstance(Context& context)
 	: RayQueryProceduralGeometryTestBase(context)
 {
 }

 void ObjectBehindBoundingBoxInstance::setupAccelerationStructures()
 {
 	const DeviceInterface&	vkd			= m_context.getDeviceInterface();
 	const VkDevice			device		= m_context.getDevice();
 	Allocator&				allocator	= m_context.getDefaultAllocator();

 	// build reference acceleration structure - single aabb big enough to fit whole procedural geometry
 	de::SharedPtr<BottomLevelAccelerationStructure> referenceBLAS(makeBottomLevelAccelerationStructure().release());
 	referenceBLAS->setGeometryData(
 		{
 			{  0.0,  0.0, -64.0 },
 			{ 64.0, 64.0, -16.0 },
 		},
 		false,
 		0
 		);
 	referenceBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 	m_blasVect.push_back(referenceBLAS);

 	m_referenceTLAS->setInstanceCount(1);
 	m_referenceTLAS->addInstance(m_blasVect.back());
 	m_referenceTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);

 	// build result acceleration structure - wall of 4 aabb's and generated object is actualy behind it (as it is just 1.0 unit thick)
 	de::SharedPtr<BottomLevelAccelerationStructure> resultBLAS(makeBottomLevelAccelerationStructure().release());
 	resultBLAS->setGeometryData(
 		{
 			{  0.0,  0.0, 0.0 },	// |  |
 			{ 32.0, 32.0, 1.0 },	// |* |
 			{ 32.0,  0.0, 0.0 },	//    |  |
 			{ 64.0, 32.0, 1.0 },	//    | *|
 			{  0.0, 32.0, 0.0 },	// |* |
 			{ 32.0, 64.0, 1.0 },	// |  |
 			{ 32.0, 32.0, 0.0 },	//    | *|
 			{ 64.0, 64.0, 1.0 },	//    |  |
 		},
 		false,
 		0
 		);
 	resultBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 	m_blasVect.push_back(resultBLAS);

 	m_resultTLAS->setInstanceCount(1);
 	m_resultTLAS->addInstance(m_blasVect.back());
 	m_resultTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 }

 class TriangleInBeteenInstance : public RayQueryProceduralGeometryTestBase
 {
 public:

 	TriangleInBeteenInstance(Context& context);
 	void setupAccelerationStructures() override;
 };

 TriangleInBeteenInstance::TriangleInBeteenInstance(Context& context)
 	: RayQueryProceduralGeometryTestBase(context)
 {
 }

 void TriangleInBeteenInstance::setupAccelerationStructures()
 {
 	const DeviceInterface&	vkd			= m_context.getDeviceInterface();
 	const VkDevice			device		= m_context.getDevice();
 	Allocator&				allocator	= m_context.getDefaultAllocator();

 	de::SharedPtr<BottomLevelAccelerationStructure> triangleBLAS(makeBottomLevelAccelerationStructure().release());
 	triangleBLAS->setGeometryData(
 		{
 			{ 16.0, 16.0, -8.0 },
 			{ 56.0, 32.0, -8.0 },
 			{ 32.0, 48.0, -8.0 },
 		},
 		true,
 		VK_GEOMETRY_OPAQUE_BIT_KHR
 		);
 	triangleBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 	m_blasVect.push_back(triangleBLAS);

 	de::SharedPtr<BottomLevelAccelerationStructure> fullElipsoidBLAS(makeBottomLevelAccelerationStructure().release());
 	fullElipsoidBLAS->setGeometryData(
 		{
 			{  0.0,  0.0, -64.0 },
 			{ 64.0, 64.0, -16.0 },
 		},
 		false,
 		0
 		);
 	fullElipsoidBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 	m_blasVect.push_back(fullElipsoidBLAS);

 	// build reference acceleration structure - triangle and a single aabb big enough to fit whole procedural geometry
 	m_referenceTLAS->setInstanceCount(2);
 	m_referenceTLAS->addInstance(fullElipsoidBLAS);
 	m_referenceTLAS->addInstance(triangleBLAS);
 	m_referenceTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);

 	de::SharedPtr<BottomLevelAccelerationStructure> elipsoidWallBLAS(makeBottomLevelAccelerationStructure().release());
 	elipsoidWallBLAS->setGeometryData(
 		{
 			{  0.0,  0.0, 0.0 },	// |*  |
 			{ 20.0, 64.0, 1.0 },
 			{ 20.0,  0.0, 0.0 },	// | * |
 			{ 44.0, 64.0, 1.0 },
 			{ 44.0,  0.0, 0.0 },	// |  *|
 			{ 64.0, 64.0, 1.0 },
 		},
 		false,
 		0
 		);
 	elipsoidWallBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 	m_blasVect.push_back(elipsoidWallBLAS);

 	// build result acceleration structure - triangle and a three aabb's (they are in front of triangle but generate intersections behind it)
 	m_resultTLAS->setInstanceCount(2);
 	m_resultTLAS->addInstance(elipsoidWallBLAS);
 	m_resultTLAS->addInstance(triangleBLAS);
 	m_resultTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
 }

 class RayQueryProceduralGeometryTestCase : public TestCase
 {
 public:
 	RayQueryProceduralGeometryTestCase		(tcu::TestContext& context, const char* name, TestType testType);
 	~RayQueryProceduralGeometryTestCase		(void) = default;

 	void				checkSupport			(Context& context) const override;
 	void				initPrograms			(SourceCollections& programCollection) const override;
 	TestInstance*		createInstance			(Context& context) const override;

 protected:
 	TestType m_testType;
 };

 RayQueryProceduralGeometryTestCase::RayQueryProceduralGeometryTestCase(tcu::TestContext& context, const char* name, TestType testType)
 	: TestCase		(context, name, "")
 	, m_testType	(testType)
 {
 }

 void RayQueryProceduralGeometryTestCase::checkSupport(Context& context) const
 {
 	context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
 	context.requireDeviceFunctionality("VK_KHR_ray_query");

 	if (!context.getRayQueryFeatures().rayQuery)
 		TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayQueryFeaturesKHR.rayQuery");

 	if (!context.getAccelerationStructureFeatures().accelerationStructure)
 		TCU_THROW(TestError, "Requires VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure");
 }

 void RayQueryProceduralGeometryTestCase::initPrograms(SourceCollections& programCollection) const
 {
 	const vk::ShaderBuildOptions glslBuildOptions(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);

 	std::string compSource =
 		"#version 460 core\n"
 		"#extension GL_EXT_ray_query : require\n"

 		"layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
 		"layout(set = 0, binding = 1, std430) writeonly buffer Result {\n"
 		"    int value[];\n"
 		"} result;\n"

 		"void main()\n"
 		"{\n"
 		"  float tmin          = 0.0;\n"
 		"  float tmax          = 50.0;\n"
 		"  vec3  rayOrigin     = vec3(float(gl_GlobalInvocationID.x) + 0.5f, float(gl_GlobalInvocationID.y) + 0.5f, 2.0);\n"
 		"  vec3  rayDir        = vec3(0.0,0.0,-1.0);\n"
 		"  uint  resultIndex   = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x;\n"
 		"  int   payload       = 30;\n"

 		// elipsoid center and radii
 		"  vec3 elipsoidOrigin = vec3(32.0, 32.0, -30.0);\n"
 		"  vec3 elipsoidRadii  = vec3(30.0, 15.0, 5.0);\n"

 		"  rayQueryEXT rq;\n"
 		"  rayQueryInitializeEXT(rq, tlas, gl_RayFlagsCullBackFacingTrianglesEXT, 0xFF, rayOrigin, tmin, rayDir, tmax);\n"

 		"  while (rayQueryProceedEXT(rq))\n"
 		"  {\n"
 		"    uint intersectionType = rayQueryGetIntersectionTypeEXT(rq, false);\n"
 		"    if (intersectionType == gl_RayQueryCandidateIntersectionAABBEXT)\n"
 		"    {\n"
 		// simplify to ray sphere intersection
 		"      vec3  eliDir = rayOrigin - elipsoidOrigin;\n"
 		"      vec3  eliS   = eliDir / elipsoidRadii;\n"
 		"      vec3  rayS   = rayDir / elipsoidRadii;\n"

 		"      float a = dot(rayS, rayS);\n"
 		"      float b = dot(eliS, rayS);\n"
 		"      float c = dot(eliS, eliS);\n"
 		"      float h = b * b - a * (c - 1.0);\n"
 		"      if (h >= 0.0)\n"
 		"        rayQueryGenerateIntersectionEXT(rq, (-b - sqrt(h)) / a);\n"
 		"    }\n"
 		"    else if (intersectionType == gl_RayQueryCandidateIntersectionTriangleEXT)\n"
 		"    {\n"
 		"      payload = 250;\n"
 		"      rayQueryConfirmIntersectionEXT(rq);\n"
 		"    }\n"
 		"  }\n"
 		"  if (rayQueryGetIntersectionTypeEXT(rq, true) != gl_RayQueryCommittedIntersectionNoneEXT)\n"
 		"  {\n"
 		"    int instanceId = rayQueryGetIntersectionInstanceIdEXT(rq, true);\n"
 		"    if (instanceId > -1)\n"
 		"    {\n"
 		"      float hitT      = rayQueryGetIntersectionTEXT(rq, true);\n"
 		"      vec3  lightDir  = normalize(vec3(0.0, 0.0, 1.0));\n"
 		"      vec3  hitPos    = rayOrigin + hitT * rayDir;\n"
 		"      vec3  hitNormal = normalize((hitPos - elipsoidOrigin) / elipsoidRadii);\n"
 		"      payload = 50 + int(200.0 * clamp(dot(hitNormal, lightDir), 0.0, 1.0));\n"
 		"    }\n"
 		"  }\n"

 		// to be able to display result in cherry this is interpreated as r8g8b8a8 during verification
 		// we are using only red but we need to add alpha (note: r and a may be swapped depending on endianness)
 		"  result.value[resultIndex] = payload + 0xFF000000;\n"
 		"};\n";
 	programCollection.glslSources.add("comp") << glu::ComputeSource(compSource) << glslBuildOptions;
 }

 TestInstance* RayQueryProceduralGeometryTestCase::createInstance(Context& context) const
 {
 	if (m_testType == TestType::TRIANGLE_IN_BETWEEN)
 		return new TriangleInBeteenInstance(context);

 	// TestType::OBJECT_BEHIND_BOUNDING_BOX
 	return new ObjectBehindBoundingBoxInstance(context);
 }

 }	// anonymous

 tcu::TestCaseGroup*	createProceduralGeometryTests(tcu::TestContext& testCtx)
 {
 	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "procedural_geometry", "Test procedural geometry with complex bouding box sets"));

 	group->addChild(new RayQueryProceduralGeometryTestCase(testCtx, "object_behind_bounding_boxes",	TestType::OBJECT_BEHIND_BOUNDING_BOX));
 	group->addChild(new RayQueryProceduralGeometryTestCase(testCtx, "triangle_in_between",			TestType::TRIANGLE_IN_BETWEEN));

 	return group.release();
 }

 }	// RayQuery

 }	// vkt
	/*------------------------------------------------------------------------
	* 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 Test procedural geometry with complex bouding box sets
	//--------------------------------------------------------------------*/

	#include "vktRayQueryProceduralGeometryTests.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 "vkRayTracingUtil.hpp"
	#include "tcuVectorUtil.hpp"
	#include "tcuTexture.hpp"
	#include "tcuTestLog.hpp"
	#include "tcuImageCompare.hpp"
	#include "tcuFloat.hpp"

	namespace vkt
	{
	namespace RayQuery
	{
	namespace
	{
	using namespace vk;
	using namespace vkt;

	enum class TestType
	{
	OBJECT_BEHIND_BOUNDING_BOX = 0,
	TRIANGLE_IN_BETWEEN
	};

	class RayQueryProceduralGeometryTestBase : public TestInstance
	{
	public:

	RayQueryProceduralGeometryTestBase (Context& context);
	~RayQueryProceduralGeometryTestBase (void) = default;

	tcu::TestStatus iterate (void) override;

	protected:

	virtual void setupAccelerationStructures() = 0;

	private:

	VkWriteDescriptorSetAccelerationStructureKHR makeASWriteDescriptorSet (const VkAccelerationStructureKHR* pAccelerationStructure);
	void clearBuffer (de::SharedPtr<BufferWithMemory> buffer, VkDeviceSize bufferSize);

	protected:

	Move<VkCommandPool> m_cmdPool;
	Move<VkCommandBuffer> m_cmdBuffer;

	std::vector<de::SharedPtr<BottomLevelAccelerationStructure> > m_blasVect;
	de::SharedPtr<TopLevelAccelerationStructure> m_referenceTLAS;
	de::SharedPtr<TopLevelAccelerationStructure> m_resultTLAS;
	};

	RayQueryProceduralGeometryTestBase::RayQueryProceduralGeometryTestBase(Context& context)
	: vkt::TestInstance (context)
	, m_referenceTLAS (makeTopLevelAccelerationStructure().release())
	, m_resultTLAS (makeTopLevelAccelerationStructure().release())
	{
	}

	tcu::TestStatus RayQueryProceduralGeometryTestBase::iterate(void)
	{
	const DeviceInterface& vkd = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
	const VkQueue queue = m_context.getUniversalQueue();
	Allocator& allocator = m_context.getDefaultAllocator();
	const deUint32 imageSize = 64u;

	const Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder()
	.addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 2u)
	.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2u)
	.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 2u);

	Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
	.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, VK_SHADER_STAGE_COMPUTE_BIT) // as with single/four aabb's
	.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT) // ssbo with result/reference values
	.build(vkd, device);

	const Move<VkDescriptorSet> referenceDescriptorSet = makeDescriptorSet(vkd, device, descriptorPool, descriptorSetLayout);
	const Move<VkDescriptorSet> resultDescriptorSet = makeDescriptorSet(vkd, device, descriptorPool, descriptorSetLayout);

	const VkDeviceSize resultBufferSize = imageSize * imageSize * sizeof(int);
	const VkBufferCreateInfo resultBufferCreateInfo = makeBufferCreateInfo(resultBufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT \| VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
	de::SharedPtr<BufferWithMemory> referenceBuffer = de::SharedPtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));
	de::SharedPtr<BufferWithMemory> resultBuffer = de::SharedPtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));

	Move<VkShaderModule> shaderModule = createShaderModule(vkd, device, m_context.getBinaryCollection().get("comp"), 0u);
	const Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vkd, device, descriptorSetLayout.get());
	const VkComputePipelineCreateInfo pipelineCreateInfo
	{
	VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType
	DE_NULL, // const void* pNext
	0u, // VkPipelineCreateFlags flags
	{ // VkPipelineShaderStageCreateInfo stage
	VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
	DE_NULL,
	(VkPipelineShaderStageCreateFlags)0,
	VK_SHADER_STAGE_COMPUTE_BIT,
	*shaderModule,
	"main",
	DE_NULL
	},
	*pipelineLayout, // VkPipelineLayout layout
	DE_NULL, // VkPipeline basePipelineHandle
	0, // deInt32 basePipelineIndex
	};
	Move<VkPipeline> pipeline = createComputePipeline(vkd, device, DE_NULL, &pipelineCreateInfo);

	m_cmdPool = createCommandPool(vkd, device, 0, queueFamilyIndex);
	m_cmdBuffer = allocateCommandBuffer(vkd, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	// clear result and reference buffers
	clearBuffer(resultBuffer, resultBufferSize);
	clearBuffer(referenceBuffer, resultBufferSize);

	beginCommandBuffer(vkd, *m_cmdBuffer, 0u);
	{
	setupAccelerationStructures();

	// update descriptor sets
	{
	typedef DescriptorSetUpdateBuilder::Location DSL;

	const VkWriteDescriptorSetAccelerationStructureKHR referenceAS = makeASWriteDescriptorSet(m_referenceTLAS->getPtr());
	const VkDescriptorBufferInfo referenceSSBO = makeDescriptorBufferInfo(**referenceBuffer, 0u, VK_WHOLE_SIZE);
	DescriptorSetUpdateBuilder()
	.writeSingle(*referenceDescriptorSet, DSL::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &referenceAS)
	.writeSingle(*referenceDescriptorSet, DSL::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &referenceSSBO)
	.update(vkd, device);

	const VkWriteDescriptorSetAccelerationStructureKHR resultAS = makeASWriteDescriptorSet(m_resultTLAS->getPtr());
	const VkDescriptorBufferInfo resultSSBO = makeDescriptorBufferInfo(**resultBuffer, 0u, VK_WHOLE_SIZE);
	DescriptorSetUpdateBuilder()
	.writeSingle(*resultDescriptorSet, DSL::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &resultAS)
	.writeSingle(*resultDescriptorSet, DSL::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultSSBO)
	.update(vkd, device);
	}

	// wait for data transfers
	const VkMemoryBarrier bufferUploadBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT);
	cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, &bufferUploadBarrier, 1u);

	// wait for as build
	const VkMemoryBarrier asBuildBarrier = makeMemoryBarrier(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_SHADER_READ_BIT);
	cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, &asBuildBarrier, 1u);

	vkd.cmdBindPipeline(m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);

	// generate reference
	vkd.cmdBindDescriptorSets(m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &referenceDescriptorSet.get(), 0, DE_NULL);
	vkd.cmdDispatch(*m_cmdBuffer, imageSize, imageSize, 1);

	// generate result
	vkd.cmdBindDescriptorSets(m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &resultDescriptorSet.get(), 0, DE_NULL);
	vkd.cmdDispatch(*m_cmdBuffer, imageSize, imageSize, 1);

	const VkMemoryBarrier postTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
	cmdPipelineMemoryBarrier(vkd, *m_cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTraceMemoryBarrier);
	}
	endCommandBuffer(vkd, *m_cmdBuffer);

	submitCommandsAndWait(vkd, device, queue, m_cmdBuffer.get());

	// verify result buffer
	auto referenceAllocation = referenceBuffer->getAllocation();
	invalidateMappedMemoryRange(vkd, device, referenceAllocation.getMemory(), referenceAllocation.getOffset(), resultBufferSize);

	auto resultAllocation = resultBuffer->getAllocation();
	invalidateMappedMemoryRange(vkd, device, resultAllocation.getMemory(), resultAllocation.getOffset(), resultBufferSize);

	tcu::TextureFormat imageFormat (vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
	tcu::PixelBufferAccess referenceAccess (imageFormat, imageSize, imageSize, 1, referenceAllocation.getHostPtr());
	tcu::PixelBufferAccess resultAccess (imageFormat, imageSize, imageSize, 1, resultAllocation.getHostPtr());

	if (tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Result comparison", "", referenceAccess, resultAccess, tcu::UVec4(0), tcu::COMPARE_LOG_EVERYTHING))
	return tcu::TestStatus::pass("Pass");
	return tcu::TestStatus::fail("Fail");
	}

	VkWriteDescriptorSetAccelerationStructureKHR RayQueryProceduralGeometryTestBase::makeASWriteDescriptorSet(const VkAccelerationStructureKHR* pAccelerationStructure)
	{
	return
	{
	VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, // VkStructureType sType
	DE_NULL, // const void* pNext
	1u, // deUint32 accelerationStructureCount
	pAccelerationStructure // const VkAccelerationStructureKHR* pAccelerationStructures
	};
	}

	void RayQueryProceduralGeometryTestBase::clearBuffer(de::SharedPtr<BufferWithMemory> buffer, VkDeviceSize bufferSize)
	{
	const DeviceInterface& vkd = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	auto& bufferAlloc = buffer->getAllocation();
	void* bufferPtr = bufferAlloc.getHostPtr();

	deMemset(bufferPtr, 1, static_cast<size_t>(bufferSize));
	vk::flushAlloc(vkd, device, bufferAlloc);
	}

	class ObjectBehindBoundingBoxInstance : public RayQueryProceduralGeometryTestBase
	{
	public:

	ObjectBehindBoundingBoxInstance(Context& context);
	void setupAccelerationStructures() override;
	};

	ObjectBehindBoundingBoxInstance::ObjectBehindBoundingBoxInstance(Context& context)
	: RayQueryProceduralGeometryTestBase(context)
	{
	}

	void ObjectBehindBoundingBoxInstance::setupAccelerationStructures()
	{
	const DeviceInterface& vkd = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	Allocator& allocator = m_context.getDefaultAllocator();

	// build reference acceleration structure - single aabb big enough to fit whole procedural geometry
	de::SharedPtr<BottomLevelAccelerationStructure> referenceBLAS(makeBottomLevelAccelerationStructure().release());
	referenceBLAS->setGeometryData(
	{
	{ 0.0, 0.0, -64.0 },
	{ 64.0, 64.0, -16.0 },
	},
	false,
	0
	);
	referenceBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	m_blasVect.push_back(referenceBLAS);

	m_referenceTLAS->setInstanceCount(1);
	m_referenceTLAS->addInstance(m_blasVect.back());
	m_referenceTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);

	// build result acceleration structure - wall of 4 aabb's and generated object is actualy behind it (as it is just 1.0 unit thick)
	de::SharedPtr<BottomLevelAccelerationStructure> resultBLAS(makeBottomLevelAccelerationStructure().release());
	resultBLAS->setGeometryData(
	{
	{ 0.0, 0.0, 0.0 }, // \| \|
	{ 32.0, 32.0, 1.0 }, // \|* \|
	{ 32.0, 0.0, 0.0 }, // \| \|
	{ 64.0, 32.0, 1.0 }, // \| *\|
	{ 0.0, 32.0, 0.0 }, // \|* \|
	{ 32.0, 64.0, 1.0 }, // \| \|
	{ 32.0, 32.0, 0.0 }, // \| *\|
	{ 64.0, 64.0, 1.0 }, // \| \|
	},
	false,
	0
	);
	resultBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	m_blasVect.push_back(resultBLAS);

	m_resultTLAS->setInstanceCount(1);
	m_resultTLAS->addInstance(m_blasVect.back());
	m_resultTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	}

	class TriangleInBeteenInstance : public RayQueryProceduralGeometryTestBase
	{
	public:

	TriangleInBeteenInstance(Context& context);
	void setupAccelerationStructures() override;
	};

	TriangleInBeteenInstance::TriangleInBeteenInstance(Context& context)
	: RayQueryProceduralGeometryTestBase(context)
	{
	}

	void TriangleInBeteenInstance::setupAccelerationStructures()
	{
	const DeviceInterface& vkd = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	Allocator& allocator = m_context.getDefaultAllocator();

	de::SharedPtr<BottomLevelAccelerationStructure> triangleBLAS(makeBottomLevelAccelerationStructure().release());
	triangleBLAS->setGeometryData(
	{
	{ 16.0, 16.0, -8.0 },
	{ 56.0, 32.0, -8.0 },
	{ 32.0, 48.0, -8.0 },
	},
	true,
	VK_GEOMETRY_OPAQUE_BIT_KHR
	);
	triangleBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	m_blasVect.push_back(triangleBLAS);

	de::SharedPtr<BottomLevelAccelerationStructure> fullElipsoidBLAS(makeBottomLevelAccelerationStructure().release());
	fullElipsoidBLAS->setGeometryData(
	{
	{ 0.0, 0.0, -64.0 },
	{ 64.0, 64.0, -16.0 },
	},
	false,
	0
	);
	fullElipsoidBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	m_blasVect.push_back(fullElipsoidBLAS);

	// build reference acceleration structure - triangle and a single aabb big enough to fit whole procedural geometry
	m_referenceTLAS->setInstanceCount(2);
	m_referenceTLAS->addInstance(fullElipsoidBLAS);
	m_referenceTLAS->addInstance(triangleBLAS);
	m_referenceTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);

	de::SharedPtr<BottomLevelAccelerationStructure> elipsoidWallBLAS(makeBottomLevelAccelerationStructure().release());
	elipsoidWallBLAS->setGeometryData(
	{
	{ 0.0, 0.0, 0.0 }, // \|* \|
	{ 20.0, 64.0, 1.0 },
	{ 20.0, 0.0, 0.0 }, // \| * \|
	{ 44.0, 64.0, 1.0 },
	{ 44.0, 0.0, 0.0 }, // \| *\|
	{ 64.0, 64.0, 1.0 },
	},
	false,
	0
	);
	elipsoidWallBLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	m_blasVect.push_back(elipsoidWallBLAS);

	// build result acceleration structure - triangle and a three aabb's (they are in front of triangle but generate intersections behind it)
	m_resultTLAS->setInstanceCount(2);
	m_resultTLAS->addInstance(elipsoidWallBLAS);
	m_resultTLAS->addInstance(triangleBLAS);
	m_resultTLAS->createAndBuild(vkd, device, *m_cmdBuffer, allocator);
	}

	class RayQueryProceduralGeometryTestCase : public TestCase
	{
	public:
	RayQueryProceduralGeometryTestCase (tcu::TestContext& context, const char* name, TestType testType);
	~RayQueryProceduralGeometryTestCase (void) = default;

	void checkSupport (Context& context) const override;
	void initPrograms (SourceCollections& programCollection) const override;
	TestInstance* createInstance (Context& context) const override;

	protected:
	TestType m_testType;
	};

	RayQueryProceduralGeometryTestCase::RayQueryProceduralGeometryTestCase(tcu::TestContext& context, const char* name, TestType testType)
	: TestCase (context, name, "")
	, m_testType (testType)
	{
	}

	void RayQueryProceduralGeometryTestCase::checkSupport(Context& context) const
	{
	context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
	context.requireDeviceFunctionality("VK_KHR_ray_query");

	if (!context.getRayQueryFeatures().rayQuery)
	TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayQueryFeaturesKHR.rayQuery");

	if (!context.getAccelerationStructureFeatures().accelerationStructure)
	TCU_THROW(TestError, "Requires VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure");
	}

	void RayQueryProceduralGeometryTestCase::initPrograms(SourceCollections& programCollection) const
	{
	const vk::ShaderBuildOptions glslBuildOptions(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);

	std::string compSource =
	"#version 460 core\n"
	"#extension GL_EXT_ray_query : require\n"

	"layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
	"layout(set = 0, binding = 1, std430) writeonly buffer Result {\n"
	" int value[];\n"
	"} result;\n"

	"void main()\n"
	"{\n"
	" float tmin = 0.0;\n"
	" float tmax = 50.0;\n"
	" vec3 rayOrigin = vec3(float(gl_GlobalInvocationID.x) + 0.5f, float(gl_GlobalInvocationID.y) + 0.5f, 2.0);\n"
	" vec3 rayDir = vec3(0.0,0.0,-1.0);\n"
	" uint resultIndex = gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_NumWorkGroups.x;\n"
	" int payload = 30;\n"

	// elipsoid center and radii
	" vec3 elipsoidOrigin = vec3(32.0, 32.0, -30.0);\n"
	" vec3 elipsoidRadii = vec3(30.0, 15.0, 5.0);\n"

	" rayQueryEXT rq;\n"
	" rayQueryInitializeEXT(rq, tlas, gl_RayFlagsCullBackFacingTrianglesEXT, 0xFF, rayOrigin, tmin, rayDir, tmax);\n"

	" while (rayQueryProceedEXT(rq))\n"
	" {\n"
	" uint intersectionType = rayQueryGetIntersectionTypeEXT(rq, false);\n"
	" if (intersectionType == gl_RayQueryCandidateIntersectionAABBEXT)\n"
	" {\n"
	// simplify to ray sphere intersection
	" vec3 eliDir = rayOrigin - elipsoidOrigin;\n"
	" vec3 eliS = eliDir / elipsoidRadii;\n"
	" vec3 rayS = rayDir / elipsoidRadii;\n"

	" float a = dot(rayS, rayS);\n"
	" float b = dot(eliS, rayS);\n"
	" float c = dot(eliS, eliS);\n"
	" float h = b * b - a * (c - 1.0);\n"
	" if (h >= 0.0)\n"
	" rayQueryGenerateIntersectionEXT(rq, (-b - sqrt(h)) / a);\n"
	" }\n"
	" else if (intersectionType == gl_RayQueryCandidateIntersectionTriangleEXT)\n"
	" {\n"
	" payload = 250;\n"
	" rayQueryConfirmIntersectionEXT(rq);\n"
	" }\n"
	" }\n"
	" if (rayQueryGetIntersectionTypeEXT(rq, true) != gl_RayQueryCommittedIntersectionNoneEXT)\n"
	" {\n"
	" int instanceId = rayQueryGetIntersectionInstanceIdEXT(rq, true);\n"
	" if (instanceId > -1)\n"
	" {\n"
	" float hitT = rayQueryGetIntersectionTEXT(rq, true);\n"
	" vec3 lightDir = normalize(vec3(0.0, 0.0, 1.0));\n"
	" vec3 hitPos = rayOrigin + hitT * rayDir;\n"
	" vec3 hitNormal = normalize((hitPos - elipsoidOrigin) / elipsoidRadii);\n"
	" payload = 50 + int(200.0 * clamp(dot(hitNormal, lightDir), 0.0, 1.0));\n"
	" }\n"
	" }\n"

	// to be able to display result in cherry this is interpreated as r8g8b8a8 during verification
	// we are using only red but we need to add alpha (note: r and a may be swapped depending on endianness)
	" result.value[resultIndex] = payload + 0xFF000000;\n"
	"};\n";
	programCollection.glslSources.add("comp") << glu::ComputeSource(compSource) << glslBuildOptions;
	}

	TestInstance* RayQueryProceduralGeometryTestCase::createInstance(Context& context) const
	{
	if (m_testType == TestType::TRIANGLE_IN_BETWEEN)
	return new TriangleInBeteenInstance(context);

	// TestType::OBJECT_BEHIND_BOUNDING_BOX
	return new ObjectBehindBoundingBoxInstance(context);
	}

	} // anonymous

	tcu::TestCaseGroup* createProceduralGeometryTests(tcu::TestContext& testCtx)
	{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "procedural_geometry", "Test procedural geometry with complex bouding box sets"));

	group->addChild(new RayQueryProceduralGeometryTestCase(testCtx, "object_behind_bounding_boxes", TestType::OBJECT_BEHIND_BOUNDING_BOX));
	group->addChild(new RayQueryProceduralGeometryTestCase(testCtx, "triangle_in_between", TestType::TRIANGLE_IN_BETWEEN));

	return group.release();
	}

	} // RayQuery

	} // vkt