/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 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 Acceleration Structure binding tests
 *//*--------------------------------------------------------------------*/

#include "vktBindingDescriptorUpdateASTests.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 "tcuCommandLine.hpp"

#include "vkRayTracingUtil.hpp"

namespace vkt
{
namespace BindingModel
{
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 TestType
{
	TEST_TYPE_USING_RAY_QUERY		= 0,
	TEST_TYPE_USING_RAY_TRACING,
};

enum UpdateMethod
{
	UPDATE_METHOD_NORMAL = 0,			//!< use vkUpdateDescriptorSets				vkUpdateDescriptorSets
	UPDATE_METHOD_WITH_TEMPLATE,		//!< use descriptor update templates		vkUpdateDescriptorSetWithTemplate
	UPDATE_METHOD_WITH_PUSH,			//!< use push descriptor updates			vkCmdPushDescriptorSetKHR
	UPDATE_METHOD_WITH_PUSH_TEMPLATE,	//!< use push descriptor update templates	vkCmdPushDescriptorSetWithTemplateKHR

	UPDATE_METHOD_LAST
};

const deUint32	TEST_WIDTH			= 16u;
const deUint32	TEST_HEIGHT			= 16u;
const deUint32	FIXED_POINT_DIVISOR	= 1024 * 1024;
const float		PLAIN_Z0			= 2.0f;
const float		PLAIN_Z1			= 4.0f;

struct TestParams;

typedef void (*CheckSupportFunc)(Context& context, const TestParams& testParams);
typedef void (*InitProgramsFunc)(SourceCollections& programCollection, const TestParams& testParams);
typedef const std::string (*ShaderBodyTextFunc)(const TestParams& testParams);

struct TestParams
{
	deUint32				width;
	deUint32				height;
	deUint32				depth;
	TestType				testType;
	UpdateMethod			updateMethod;
	VkShaderStageFlagBits	stage;
	VkFormat				format;
	CheckSupportFunc		pipelineCheckSupport;
	InitProgramsFunc		pipelineInitPrograms;
	ShaderBodyTextFunc		testConfigShaderBodyText;
};


static deUint32 getShaderGroupHandleSize (const InstanceInterface&	vki,
										  const VkPhysicalDevice	physicalDevice)
{
	de::MovePtr<RayTracingProperties>	rayTracingPropertiesKHR;

	rayTracingPropertiesKHR	= makeRayTracingProperties(vki, physicalDevice);

	return rayTracingPropertiesKHR->getShaderGroupHandleSize();
}

static deUint32 getShaderGroupBaseAlignment (const InstanceInterface&	vki,
											 const VkPhysicalDevice		physicalDevice)
{
	de::MovePtr<RayTracingProperties>	rayTracingPropertiesKHR;

	rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);

	return rayTracingPropertiesKHR->getShaderGroupBaseAlignment();
}

static VkBuffer getVkBuffer (const de::MovePtr<BufferWithMemory>& buffer)
{
	VkBuffer result = (buffer.get() == DE_NULL) ? DE_NULL : buffer->get();

	return result;
}

static VkStridedDeviceAddressRegionKHR makeStridedDeviceAddressRegion (const DeviceInterface& vkd, const VkDevice device, VkBuffer buffer, deUint32 stride, deUint32 count)
{
	if (buffer == DE_NULL)
	{
		return makeStridedDeviceAddressRegionKHR(0, 0, 0);
	}
	else
	{
		return makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, buffer, 0), stride, stride * count);
	}
}

static Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&		vk,
												  const VkDevice				device,
												  const VkDescriptorSetLayout	descriptorSetLayout0,
												  const VkDescriptorSetLayout	descriptorSetLayout1,
												  const VkDescriptorSetLayout	descriptorSetLayoutOpt = DE_NULL)
{
	std::vector<VkDescriptorSetLayout> descriptorSetLayouts;

	descriptorSetLayouts.push_back(descriptorSetLayout0);
	descriptorSetLayouts.push_back(descriptorSetLayout1);

	if (descriptorSetLayoutOpt != DE_NULL)
		descriptorSetLayouts.push_back(descriptorSetLayoutOpt);

	return makePipelineLayout(vk, device, (deUint32)descriptorSetLayouts.size(), descriptorSetLayouts.data());
}

static VkWriteDescriptorSetAccelerationStructureKHR makeWriteDescriptorSetAccelerationStructureKHR (const VkAccelerationStructureKHR* accelerationStructureKHR)
{
	const VkWriteDescriptorSetAccelerationStructureKHR	result	=
	{
		VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,	//  VkStructureType						sType;
		DE_NULL,															//  const void*							pNext;
		1u,																	//  deUint32							accelerationStructureCount;
		accelerationStructureKHR											//  const VkAccelerationStructureKHR*	pAccelerationStructures;
	};

	return result;
}

static bool isPushUpdateMethod (const UpdateMethod	updateMethod)
{
	switch (updateMethod)
	{
		case UPDATE_METHOD_NORMAL:				return false;
		case UPDATE_METHOD_WITH_TEMPLATE:		return false;
		case UPDATE_METHOD_WITH_PUSH:			return true;
		case UPDATE_METHOD_WITH_PUSH_TEMPLATE:	return true;
		default: TCU_THROW(InternalError, "Unknown update method");
	}
}

static bool isTemplateUpdateMethod (const UpdateMethod	updateMethod)
{
	switch (updateMethod)
	{
		case UPDATE_METHOD_NORMAL:				return false;
		case UPDATE_METHOD_WITH_TEMPLATE:		return true;
		case UPDATE_METHOD_WITH_PUSH:			return false;
		case UPDATE_METHOD_WITH_PUSH_TEMPLATE:	return true;
		default: TCU_THROW(InternalError, "Unknown update method");
	}
}

static Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&		vki,
												const VkDevice				device,
												const VkDescriptorPool		descriptorPool,
												const VkDescriptorSetLayout	setLayout,
												UpdateMethod				updateMethod)
{
	const bool				pushUpdateMethod	= isPushUpdateMethod(updateMethod);
	Move<VkDescriptorSet>	descriptorSet		= pushUpdateMethod
												? vk::Move<vk::VkDescriptorSet>()
												: vk::makeDescriptorSet(vki, device, descriptorPool, setLayout, DE_NULL);

	return descriptorSet;
}

static VkImageCreateInfo makeImageCreateInfo (VkFormat			format,
											  deUint32			width,
											  deUint32			height,
											  deUint32			depth,
											  VkImageType		imageType	= VK_IMAGE_TYPE_3D,
											  VkImageUsageFlags	usageFlags	= 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;
		usageFlags,								// VkImageUsageFlags		usage;
		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode			sharingMode;
		0u,										// deUint32					queueFamilyIndexCount;
		DE_NULL,								// const deUint32*			pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED				// VkImageLayout			initialLayout;
	};

	return imageCreateInfo;
}

static Move<VkPipeline> makeComputePipeline (const DeviceInterface&		vk,
											 const VkDevice				device,
											 const VkPipelineLayout		pipelineLayout,
											 const VkShaderModule		shaderModule)
{
	const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
	{
		VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// VkStructureType						sType;
		DE_NULL,												// const void*							pNext;
		0u,														// VkPipelineShaderStageCreateFlags		flags;
		VK_SHADER_STAGE_COMPUTE_BIT,							// VkShaderStageFlagBits				stage;
		shaderModule,											// VkShaderModule						module;
		"main",													// const char*							pName;
		DE_NULL,												// const VkSpecializationInfo*			pSpecializationInfo;
	};
	const VkComputePipelineCreateInfo pipelineCreateInfo =
	{
		VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,		// VkStructureType					sType;
		DE_NULL,											// const void*						pNext;
		0u,													// VkPipelineCreateFlags			flags;
		pipelineShaderStageParams,							// VkPipelineShaderStageCreateInfo	stage;
		pipelineLayout,										// VkPipelineLayout					layout;
		DE_NULL,											// VkPipeline						basePipelineHandle;
		0,													// deInt32							basePipelineIndex;
	};

	return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
}

static const std::string getMissPassthrough (void)
{
	std::ostringstream src;

	src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
		<< "#extension GL_EXT_ray_tracing : require\n"
		<< "\n"
		<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
		<< "\n"
		<< "void main()\n"
		<< "{\n"
		<< "}\n";

	return src.str();
}

static const std::string getHitPassthrough (void)
{
	std::ostringstream src;

	src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\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 src.str();
}

static const std::string getGraphicsPassthrough (void)
{
	std::ostringstream src;

	src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
		<< "\n"
		<< "void main(void)\n"
		<< "{\n"
		<< "}\n";

	return src.str();
}

static const std::string getVertexPassthrough (void)
{
	std::ostringstream src;

	src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
		<< "\n"
		<< "layout(location = 0) in vec4 in_position;\n"
		<< "\n"
		<< "void main(void)\n"
		<< "{\n"
		<< "  gl_Position = in_position;\n"
		<< "}\n";

	return src.str();
}

static VkDescriptorSetLayoutCreateFlags getDescriptorSetLayoutCreateFlags(const UpdateMethod updateMethod)
{
	vk::VkDescriptorSetLayoutCreateFlags	extraFlags	= 0;

	if (updateMethod == UPDATE_METHOD_WITH_PUSH_TEMPLATE || updateMethod == UPDATE_METHOD_WITH_PUSH)
	{
		extraFlags |= vk::VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
	}

	return extraFlags;
}

class BindingAcceleratioStructureTestInstance : public TestInstance
{
public:
																	BindingAcceleratioStructureTestInstance		(Context&			context,
																												 const TestParams&	testParams);
	virtual															~BindingAcceleratioStructureTestInstance	() {};
	virtual tcu::TestStatus											iterate										(void);

protected:
	virtual void													initPipeline								(void) = 0;
	virtual deUint32												getExtraAccelerationDescriptorCount			(void) = 0;
	virtual VkShaderStageFlags										getShaderStageFlags							(void) = 0;
	virtual VkPipelineBindPoint										getPipelineBindPoint						(void) = 0;

	virtual void													fillCommandBuffer							(VkCommandBuffer	commandBuffer) = 0;

	virtual const	VkAccelerationStructureKHR*						createAccelerationStructures				(Context&			context,
																												 TestParams&		testParams);
	virtual void													buildAccelerationStructures					(Context&			context,
																												 TestParams&		testParams,
																												 VkCommandBuffer	commandBuffer);
	virtual bool													verify										(BufferWithMemory*	resultBuffer,
																												 Context&			context,
																												 TestParams&		testParams);

	TestParams														m_testParams;

	std::vector<de::SharedPtr<BottomLevelAccelerationStructure>>	m_bottomAccelerationStructures;
	de::SharedPtr<TopLevelAccelerationStructure>					m_topAccelerationStructure;

	Move<VkDescriptorPool>											m_descriptorPool;

	Move<VkDescriptorSetLayout>										m_descriptorSetLayoutImg;
	Move<VkDescriptorSet>											m_descriptorSetImg;

	Move<VkDescriptorSetLayout>										m_descriptorSetLayoutAS;
	Move<VkDescriptorSet>											m_descriptorSetAS;

	Move<VkPipelineLayout>											m_pipelineLayout;
	Move<VkPipeline>												m_pipeline;

	Move<VkDescriptorUpdateTemplate>								m_updateTemplate;
};

BindingAcceleratioStructureTestInstance::BindingAcceleratioStructureTestInstance (Context& context, const TestParams& testParams)
	: TestInstance						(context)
	, m_testParams						(testParams)
	, m_bottomAccelerationStructures	()
	, m_topAccelerationStructure		()
	, m_descriptorPool					()
	, m_descriptorSetLayoutImg			()
	, m_descriptorSetImg				()
	, m_descriptorSetLayoutAS			()
	, m_descriptorSetAS					()
	, m_pipelineLayout					()
	, m_pipeline						()
	, m_updateTemplate					()
{
}

tcu::TestStatus BindingAcceleratioStructureTestInstance::iterate (void)
{
	const DeviceInterface&								vkd										= m_context.getDeviceInterface();
	const VkDevice										device									= m_context.getDevice();
	const VkQueue										queue									= m_context.getUniversalQueue();
	Allocator&											allocator								= m_context.getDefaultAllocator();
	const deUint32										queueFamilyIndex						= m_context.getUniversalQueueFamilyIndex();
	const bool											templateUpdateMethod					= isTemplateUpdateMethod(m_testParams.updateMethod);
	const bool											pushUpdateMethod						= isPushUpdateMethod(m_testParams.updateMethod);

	const deUint32										width									= m_testParams.width;
	const deUint32										height									= m_testParams.height;
	const deUint32										depth									= m_testParams.depth;
	const VkImageCreateInfo								imageCreateInfo							= makeImageCreateInfo(m_testParams.format, width, height, depth);
	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, m_testParams.format, imageSubresourceRange);

	const deUint32										pixelSize								= mapVkFormat(m_testParams.format).getPixelSize();
	const VkBufferCreateInfo							resultBufferCreateInfo					= makeBufferCreateInfo(width * height * depth * pixelSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	const VkImageSubresourceLayers						resultBufferImageSubresourceLayers		= makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
	const VkBufferImageCopy								resultBufferImageRegion					= makeBufferImageCopy(makeExtent3D(width, height, depth), resultBufferImageSubresourceLayers);
	de::MovePtr<BufferWithMemory>						resultBuffer							= de::MovePtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));
	const VkDescriptorImageInfo							resultImageInfo							= makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL);

	const Move<VkCommandPool>							commandPool								= createCommandPool(vkd, device, 0, queueFamilyIndex);
	const Move<VkCommandBuffer>							commandBuffer							= allocateCommandBuffer(vkd, device, *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
	const VkAccelerationStructureKHR*					topAccelerationStructurePtr				= createAccelerationStructures(m_context, m_testParams);
	const VkWriteDescriptorSetAccelerationStructureKHR	writeDescriptorSetAccelerationStructure	= makeWriteDescriptorSetAccelerationStructureKHR(topAccelerationStructurePtr);
	const deUint32										accelerationStructureDescriptorCount	= 1 + getExtraAccelerationDescriptorCount();
	deUint32											updateCount								= 0;

	m_descriptorPool			= DescriptorPoolBuilder()
									.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
									.addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, accelerationStructureDescriptorCount)
									.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u + accelerationStructureDescriptorCount);

	m_descriptorSetLayoutImg	= DescriptorSetLayoutBuilder()
									.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, getShaderStageFlags())
									.build(vkd, device);
	m_descriptorSetImg			= makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutImg);

	DescriptorSetUpdateBuilder()
		.writeSingle(*m_descriptorSetImg, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &resultImageInfo)
		.update(vkd, device);

	m_descriptorSetLayoutAS		= DescriptorSetLayoutBuilder()
									.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, getShaderStageFlags())
									.build(vkd, device, getDescriptorSetLayoutCreateFlags(m_testParams.updateMethod));
	m_descriptorSetAS			= makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutAS, m_testParams.updateMethod);

	initPipeline();

	if (m_testParams.updateMethod == UPDATE_METHOD_NORMAL)
	{
		DescriptorSetUpdateBuilder()
			.writeSingle(*m_descriptorSetAS, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &writeDescriptorSetAccelerationStructure)
			.update(vkd, device);

		updateCount++;
	}

	if (templateUpdateMethod)
	{
		const VkDescriptorUpdateTemplateType		updateTemplateType		= isPushUpdateMethod(m_testParams.updateMethod)
																			? VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
																			: VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
		const VkDescriptorUpdateTemplateEntry		updateTemplateEntry		=
		{
			0,												//  deUint32			dstBinding;
			0,												//  deUint32			dstArrayElement;
			1,												//  deUint32			descriptorCount;
			VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,	//  VkDescriptorType	descriptorType;
			0,												//  deUintptr			offset;
			0,												//  deUintptr			stride;
		};
		const VkDescriptorUpdateTemplateCreateInfo	templateCreateInfo	=
		{
			VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,	//  VkStructureType							sType;
			DE_NULL,														//  const void*								pNext;
			0,																//  VkDescriptorUpdateTemplateCreateFlags	flags;
			1,																//  deUint32								descriptorUpdateEntryCount;
			&updateTemplateEntry,											//  const VkDescriptorUpdateTemplateEntry*	pDescriptorUpdateEntries;
			updateTemplateType,												//  VkDescriptorUpdateTemplateType			templateType;
			*m_descriptorSetLayoutAS,										//  VkDescriptorSetLayout					descriptorSetLayout;
			getPipelineBindPoint(),											//  VkPipelineBindPoint						pipelineBindPoint;
			*m_pipelineLayout,												//  VkPipelineLayout						pipelineLayout;
			0,																//  deUint32								set;
		};

		m_updateTemplate = vk::createDescriptorUpdateTemplate(vkd, device, &templateCreateInfo);

		if (!pushUpdateMethod)
		{
			vkd.updateDescriptorSetWithTemplate(device, *m_descriptorSetAS, *m_updateTemplate, topAccelerationStructurePtr);

			updateCount++;
		}
	}

	beginCommandBuffer(vkd, *commandBuffer, 0u);
	{
		{
			const VkClearValue			clearValue				= makeClearValueColorU32(0u, 0u, 0u, 0u);
			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);

			cmdPipelineImageMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &preImageBarrier);
			vkd.cmdClearColorImage(*commandBuffer, **image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue.color, 1, &imageSubresourceRange);
			cmdPipelineImageMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, &postImageBarrier);

			vkd.cmdBindDescriptorSets(*commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 1, 1, &m_descriptorSetImg.get(), 0, DE_NULL);
		}

		switch (m_testParams.updateMethod)
		{
			case UPDATE_METHOD_NORMAL:			// fallthrough
			case UPDATE_METHOD_WITH_TEMPLATE:
			{
				vkd.cmdBindDescriptorSets(*commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 0, 1, &m_descriptorSetAS.get(), 0, DE_NULL);

				break;
			}

			case UPDATE_METHOD_WITH_PUSH:
			{
				DescriptorSetUpdateBuilder()
					.writeSingle(*m_descriptorSetAS, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &writeDescriptorSetAccelerationStructure)
					.updateWithPush(vkd, *commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 0, 0, 1);

				updateCount++;

				break;
			}

			case UPDATE_METHOD_WITH_PUSH_TEMPLATE:
			{
				vkd.cmdPushDescriptorSetWithTemplateKHR(*commandBuffer, *m_updateTemplate, *m_pipelineLayout, 0, topAccelerationStructurePtr);

				updateCount++;

				break;
			}

			default: TCU_THROW(InternalError, "Unknown update method");
		}

		{
			const VkMemoryBarrier		preTraceMemoryBarrier	= makeMemoryBarrier(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR);
			const VkPipelineStageFlags	dstStageFlags			= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;

			buildAccelerationStructures(m_context, m_testParams, *commandBuffer);

			cmdPipelineMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, dstStageFlags, &preTraceMemoryBarrier);
		}

		fillCommandBuffer(*commandBuffer);

		{
			const VkMemoryBarrier		postTestMemoryBarrier	= makeMemoryBarrier(VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);

			cmdPipelineMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTestMemoryBarrier);
		}

		vkd.cmdCopyImageToBuffer(*commandBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **resultBuffer, 1u, &resultBufferImageRegion);
	}
	endCommandBuffer(vkd, *commandBuffer);

	if (updateCount != 1)
		TCU_THROW(InternalError, "Invalid descriptor update");

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

	invalidateMappedMemoryRange(vkd, device, resultBuffer->getAllocation().getMemory(), resultBuffer->getAllocation().getOffset(), VK_WHOLE_SIZE);

	if (verify(resultBuffer.get(), m_context, m_testParams))
		return tcu::TestStatus::pass("Pass");
	else
		return tcu::TestStatus::fail("Fail");
}

const VkAccelerationStructureKHR* BindingAcceleratioStructureTestInstance::createAccelerationStructures (Context&		context,
																										 TestParams&	testParams)
{
	DE_UNREF(testParams);

	const DeviceInterface&							vkd											= context.getDeviceInterface();
	const VkDevice									device										= context.getDevice();
	Allocator&										allocator									= context.getDefaultAllocator();
	de::MovePtr<BottomLevelAccelerationStructure>	rayQueryBottomLevelAccelerationStructure	= makeBottomLevelAccelerationStructure();
	de::MovePtr<TopLevelAccelerationStructure>		rayQueryTopLevelAccelerationStructure		= makeTopLevelAccelerationStructure();
	std::vector<tcu::Vec3>							geometryData;

	// Generate in-plain square starting at (0,0,PLAIN_Z0) and ending at (1,1,PLAIN_Z1).
	// Vertices 1,0 and 0,1 by Z axis are in the middle between PLAIN_Z0 and PLAIN_Z1
	geometryData.push_back(tcu::Vec3(0.0f, 0.0f, PLAIN_Z0));
	geometryData.push_back(tcu::Vec3(1.0f, 0.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
	geometryData.push_back(tcu::Vec3(0.0f, 1.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
	geometryData.push_back(tcu::Vec3(1.0f, 1.0f, PLAIN_Z1));
	geometryData.push_back(tcu::Vec3(0.0f, 1.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
	geometryData.push_back(tcu::Vec3(1.0f, 0.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));

	rayQueryBottomLevelAccelerationStructure->setGeometryCount(1u);
	rayQueryBottomLevelAccelerationStructure->addGeometry(geometryData, true);
	rayQueryBottomLevelAccelerationStructure->create(vkd, device, allocator, 0);
	m_bottomAccelerationStructures.push_back(de::SharedPtr<BottomLevelAccelerationStructure>(rayQueryBottomLevelAccelerationStructure.release()));

	m_topAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(rayQueryTopLevelAccelerationStructure.release());
	m_topAccelerationStructure->addInstance(m_bottomAccelerationStructures.back());
	m_topAccelerationStructure->create(vkd, device, allocator);

	return m_topAccelerationStructure.get()->getPtr();
}

void BindingAcceleratioStructureTestInstance::buildAccelerationStructures	(Context&			context,
																			 TestParams&		testParams,
																			 VkCommandBuffer	commandBuffer)
{
	DE_UNREF(testParams);

	const DeviceInterface&	vkd		= context.getDeviceInterface();
	const VkDevice			device	= context.getDevice();

	for (size_t blStructNdx = 0; blStructNdx < m_bottomAccelerationStructures.size(); ++blStructNdx)
		m_bottomAccelerationStructures[blStructNdx]->build(vkd, device, commandBuffer);

	m_topAccelerationStructure->build(vkd, device, commandBuffer);
}

bool BindingAcceleratioStructureTestInstance::verify (BufferWithMemory*	resultBuffer,
													  Context&			context,
													  TestParams&		testParams)
{
	tcu::TestLog&			log			= context.getTestContext().getLog();
	const deUint32			width		= testParams.width;
	const deUint32			height		= testParams.height;
	const deInt32*			retrieved	= (deInt32*)resultBuffer->getAllocation().getHostPtr();
	deUint32				failures	= 0;
	deUint32				pos			= 0;
	std::vector<deInt32>	expected;

	expected.reserve(width * height);

	for (deUint32 y = 0; y < height; ++y)
	{
		const float	expectedY	= deFloatMix(PLAIN_Z0, PLAIN_Z1, (0.5f + float(y)) / float(height));

		for (deUint32 x = 0; x < width; ++x)
		{
			const float		expectedX	= deFloatMix(PLAIN_Z0, PLAIN_Z1, (0.5f + float(x)) / float(width));
			const deInt32	expectedV	= deInt32(float(FIXED_POINT_DIVISOR / 2) * (expectedX + expectedY));

			expected.push_back(expectedV);
		}
	}

	for (deUint32 y = 0; y < height; ++y)
	for (deUint32 x = 0; x < width; ++x)
	{
		if (retrieved[pos] != expected[pos])
		{
			failures++;

			if (failures < 10)
			{
				const deInt32	expectedValue	= expected[pos];
				const deInt32	retrievedValue	= retrieved[pos];

				log << tcu::TestLog::Message
					<< "At (" << x <<"," << y << ") "
					<< "expected " << std::fixed << std::setprecision(6) << std::setw(8) << float(expectedValue) / float(FIXED_POINT_DIVISOR) << " (" << expectedValue << ") "
					<< "retrieved " << std::fixed << std::setprecision(6) << std::setw(8) << float(retrievedValue) / float(FIXED_POINT_DIVISOR) << " (" << retrievedValue << ") "
					<< tcu::TestLog::EndMessage;
			}
		}

		pos++;
	}

	if (failures != 0)
	{
		for (deUint32 dumpNdx = 0; dumpNdx < 2; ++dumpNdx)
		{
			const deInt32*		data		= (dumpNdx == 0) ? expected.data() : retrieved;
			const char*			dataName	= (dumpNdx == 0) ? "Expected" : "Retrieved";
			std::ostringstream	css;

			pos = 0;

			for (deUint32 y = 0; y < height; ++y)
			{
				for (deUint32 x = 0; x < width; ++x)
				{
					if (expected[pos] != retrieved[pos])
						css << std::fixed << std::setprecision(6) << std::setw(8) << float(data[pos]) / float(FIXED_POINT_DIVISOR) << ",";
					else
						css << "________,";

					pos++;
				}

				css << std::endl;
			}

			log << tcu::TestLog::Message << dataName << ":" << tcu::TestLog::EndMessage;
			log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage;
		}
	}

	return (failures == 0);
}


class BindingAcceleratioStructureGraphicsTestInstance : public BindingAcceleratioStructureTestInstance
{
public:
	static void							checkSupport										(Context&			context,
																							 const TestParams&	testParams);
	static void							initPrograms										(SourceCollections&	programCollection,
																							 const TestParams&	testParams);

										BindingAcceleratioStructureGraphicsTestInstance		(Context&			context,
																							 const TestParams&	testParams);
	virtual								~BindingAcceleratioStructureGraphicsTestInstance	() {};

protected:
	virtual void						initPipeline										(void) override;
	virtual void						fillCommandBuffer									(VkCommandBuffer	commandBuffer) override;

	void								initVertexBuffer									(void);
	Move<VkPipeline>					makeGraphicsPipeline								(void);

	virtual deUint32					getExtraAccelerationDescriptorCount					(void) override									{ return 0; };
	virtual VkShaderStageFlags			getShaderStageFlags									(void) override									{ return VK_SHADER_STAGE_ALL_GRAPHICS; }
	virtual VkPipelineBindPoint			getPipelineBindPoint								(void) override									{ return VK_PIPELINE_BIND_POINT_GRAPHICS; };

	VkFormat							m_framebufferFormat;
	Move<VkImage>						m_framebufferImage;
	de::MovePtr<Allocation>				m_framebufferImageAlloc;
	Move<VkImageView>					m_framebufferAttachment;

	Move<VkShaderModule>				m_vertShaderModule;
	Move<VkShaderModule>				m_geomShaderModule;
	Move<VkShaderModule>				m_tescShaderModule;
	Move<VkShaderModule>				m_teseShaderModule;
	Move<VkShaderModule>				m_fragShaderModule;

	Move<VkRenderPass>					m_renderPass;
	Move<VkFramebuffer>					m_framebuffer;

	deUint32							m_vertexCount;
	Move<VkBuffer>						m_vertexBuffer;
	de::MovePtr<Allocation>				m_vertexBufferAlloc;
};

BindingAcceleratioStructureGraphicsTestInstance::BindingAcceleratioStructureGraphicsTestInstance (Context&			context,
																								  const TestParams&	testParams)
	: BindingAcceleratioStructureTestInstance	(context, testParams)
	, m_framebufferFormat						(VK_FORMAT_R8G8B8A8_UNORM)
	, m_framebufferImage						()
	, m_framebufferImageAlloc					()
	, m_framebufferAttachment					()
	, m_vertShaderModule						()
	, m_geomShaderModule						()
	, m_tescShaderModule						()
	, m_teseShaderModule						()
	, m_fragShaderModule						()
	, m_renderPass								()
	, m_framebuffer								()
	, m_vertexCount								(0)
	, m_vertexBuffer							()
	, m_vertexBufferAlloc						()
{
}

void BindingAcceleratioStructureGraphicsTestInstance::checkSupport (Context&			context,
																	const TestParams&	testParams)
{
	switch (testParams.stage)
	{
	case VK_SHADER_STAGE_VERTEX_BIT:
	case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
	case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
	case VK_SHADER_STAGE_GEOMETRY_BIT:
		context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS);
		break;
	default:
		break;
	}

	switch (testParams.stage)
	{
	case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
	case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
		context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_TESSELLATION_SHADER);
		break;
	case VK_SHADER_STAGE_GEOMETRY_BIT:
		context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
		break;
	default:
		break;
	}
}

void BindingAcceleratioStructureGraphicsTestInstance::initPrograms (SourceCollections&	programCollection,
																	const TestParams&	testParams)
{
	const vk::ShaderBuildOptions	buildOptions	(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
	const std::string				testShaderBody	= testParams.testConfigShaderBodyText(testParams);

	switch (testParams.stage)
	{
		case VK_SHADER_STAGE_VERTEX_BIT:
		{
			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void testFunc(ivec3 pos, ivec3 size)\n"
					<< "{\n"
					<< testShaderBody
					<< "}\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  const int   posId    = int(gl_VertexIndex / 3);\n"
					<< "  const int   vertId   = int(gl_VertexIndex % 3);\n"
					<< "  const ivec3 size     = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
					<< "  const ivec3 pos      = ivec3(posId % size.x, posId / size.x, 0);\n"
					<< "\n"
					<< "  if (vertId == 0)\n"
					<< "  {\n"
					<< "    testFunc(pos, size);\n"
					<< "  }\n"
					<< "}\n";

				programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
			}

			programCollection.glslSources.add("frag") << glu::FragmentSource(getGraphicsPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
		{
			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "\n"
					<< "layout(location = 0) in vec4 in_position;\n"
					<< "out gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "};\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  gl_Position = in_position;\n"
					<< "}\n";

				programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
			}

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_tessellation_shader : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "in gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_in[];\n"
					<< "layout(vertices = 3) out;\n"
					<< "out gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_out[];\n"
					<< "\n"
					<< "void testFunc(ivec3 pos, ivec3 size)\n"
					<< "{\n"
					<< testShaderBody
					<< "}\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "\n"
					<< "  if (gl_InvocationID == 0)\n"
					<< "  {\n"
					<< "    const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
					<< "    int index = int(gl_in[gl_InvocationID].gl_Position.z);\n"
					<< "    int x = index % size.x;\n"
					<< "    int y = index / size.y;\n"
					<< "    const ivec3 pos = ivec3(x, y, 0);\n"
					<< "    testFunc(pos, size);\n"
					<< "  }\n"
					<< "\n"
					<< "  gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
					<< "  gl_TessLevelInner[0] = 1;\n"
					<< "  gl_TessLevelInner[1] = 1;\n"
					<< "  gl_TessLevelOuter[gl_InvocationID] = 1;\n"
					<< "}\n";

				programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()) << buildOptions;
			}

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_tessellation_shader : require\n"
					<< "layout(triangles, equal_spacing, ccw) in;\n"
					<< "\n"
					<< "in gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_in[];\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  gl_Position = gl_in[0].gl_Position;\n"
					<< "}\n";

				programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()) << buildOptions;
			}

			break;
		}

		case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
		{
			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "\n"
					<< "layout(location = 0) in vec4 in_position;\n"
					<< "out gl_PerVertex"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "};\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  gl_Position = in_position;\n"
					<< "}\n";

				programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
			}

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_tessellation_shader : require\n"
					<< "\n"
					<< "in gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_in[];\n"
					<< "layout(vertices = 3) out;\n"
					<< "out gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_out[];\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
					<< "  gl_TessLevelInner[0] = 1;\n"
					<< "  gl_TessLevelInner[1] = 1;\n"
					<< "  gl_TessLevelOuter[gl_InvocationID] = 1;\n"
					<< "}\n";

				programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()) << buildOptions;
			}

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_tessellation_shader : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "layout(triangles, equal_spacing, ccw) in;\n"
					<< "in gl_PerVertex\n"
					<< "{\n"
					<< "  vec4 gl_Position;\n"
					<< "} gl_in[];\n"
					<< "\n"
					<< "void testFunc(ivec3 pos, ivec3 size)\n"
					<< "{\n"
					<< testShaderBody
					<< "}\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "	const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
					<< "	int index = int(gl_in[0].gl_Position.z);\n"
					<< "	int x = index % size.x;\n"
					<< "	int y = index / size.y;\n"
					<< "	const ivec3 pos = ivec3(x, y, 0);\n"
					<< "	testFunc(pos, size);\n"
					<< "	gl_Position = gl_in[0].gl_Position;\n"
					<< "}\n";

				programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()) << buildOptions;
			}

			break;
		}

		case VK_SHADER_STAGE_GEOMETRY_BIT:
		{
			programCollection.glslSources.add("vert") << glu::VertexSource(getVertexPassthrough()) << buildOptions;

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(triangles) in;\n"
					<< "layout(points, max_vertices = 1) out;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void testFunc(ivec3 pos, ivec3 size)\n"
					<< "{\n"
					<< testShaderBody
					<< "}\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  const int   posId    = int(gl_PrimitiveIDIn);\n"
					<< "  const ivec3 size     = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
					<< "  const ivec3 pos      = ivec3(posId % size.x, posId / size.x, 0);\n"
					<< "\n"
					<< "  testFunc(pos, size);\n"
					<< "  gl_PointSize = 1.0;\n"
					<< "}\n";

				programCollection.glslSources.add("geom") << glu::GeometrySource(src.str()) << buildOptions;
			}

			break;
		}

		case VK_SHADER_STAGE_FRAGMENT_BIT:
		{
			programCollection.glslSources.add("vert") << glu::VertexSource(getVertexPassthrough()) << buildOptions;

			{
				std::ostringstream src;
				src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void testFunc(ivec3 pos, ivec3 size)\n"
					<< "{\n"
					<< testShaderBody
					<< "}\n"
					<< "\n"
					<< "void main(void)\n"
					<< "{\n"
					<< "  const ivec3 size     = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
					<< "  const ivec3 pos      = ivec3(int(gl_FragCoord.x - 0.5f), int(gl_FragCoord.y - 0.5f), 0);\n"
					<< "\n"
					<< "  testFunc(pos, size);\n"
					<< "}\n";

				programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()) << buildOptions;
			}

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown stage");
	}
}

void BindingAcceleratioStructureGraphicsTestInstance::initVertexBuffer (void)
{
	const DeviceInterface&	vkd			= m_context.getDeviceInterface();
	const VkDevice			device		= m_context.getDevice();
	const deUint32			width		= m_testParams.width;
	const deUint32			height		= m_testParams.height;
	Allocator&				allocator	= m_context.getDefaultAllocator();
	std::vector<tcu::Vec4>	vertices;

	switch (m_testParams.stage)
	{
		case VK_SHADER_STAGE_VERTEX_BIT:
		case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
		case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
		case VK_SHADER_STAGE_GEOMETRY_BIT:
		{
			float z = 0.0f;

			vertices.reserve(3 * height * width);

			for (deUint32 y = 0; y < height; ++y)
			for (deUint32 x = 0; x < width; ++x)
			{
				const float	x0	= float(x + 0) / float(width);
				const float	y0	= float(y + 0) / float(height);
				const float	x1	= float(x + 1) / float(width);
				const float	y1	= float(y + 1) / float(height);
				const float	xm	= (x0 + x1) / 2.0f;
				const float	ym	= (y0 + y1) / 2.0f;

				vertices.push_back(tcu::Vec4(x0, y0, z, 1.0f));
				vertices.push_back(tcu::Vec4(xm, y1, z, 1.0f));
				vertices.push_back(tcu::Vec4(x1, ym, z, 1.0f));

				z += 1.f;
			}

			break;
		}

		case VK_SHADER_STAGE_FRAGMENT_BIT:
		{
			const float		z = 1.0f;
			const tcu::Vec4	a = tcu::Vec4(-1.0f, -1.0f, z, 1.0f);
			const tcu::Vec4	b = tcu::Vec4(+1.0f, -1.0f, z, 1.0f);
			const tcu::Vec4	c = tcu::Vec4(-1.0f, +1.0f, z, 1.0f);
			const tcu::Vec4	d = tcu::Vec4(+1.0f, +1.0f, z, 1.0f);

			vertices.push_back(a);
			vertices.push_back(b);
			vertices.push_back(c);

			vertices.push_back(b);
			vertices.push_back(c);
			vertices.push_back(d);

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown stage");

	}

	// Initialize vertex buffer
	{
		const VkDeviceSize			vertexBufferSize		= sizeof(vertices[0][0]) * vertices[0].SIZE * vertices.size();
		const VkBufferCreateInfo	vertexBufferCreateInfo	= makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

		m_vertexCount		= static_cast<deUint32>(vertices.size());
		m_vertexBuffer		= createBuffer(vkd, device, &vertexBufferCreateInfo);
		m_vertexBufferAlloc	= bindBuffer(vkd, device, allocator, *m_vertexBuffer, vk::MemoryRequirement::HostVisible);

		deMemcpy(m_vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexBufferSize);
		flushAlloc(vkd, device, *m_vertexBufferAlloc);
	}
}

Move<VkPipeline> BindingAcceleratioStructureGraphicsTestInstance::makeGraphicsPipeline (void)
{
	const DeviceInterface&			vkd					= m_context.getDeviceInterface();
	const VkDevice					device				= m_context.getDevice();
	const bool						tessStageTest		= (m_testParams.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || m_testParams.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
	const VkPrimitiveTopology		topology			= tessStageTest ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	const deUint32					patchControlPoints	= tessStageTest ? 3 : 0;
	const std::vector<VkViewport>	viewports			(1, makeViewport(m_testParams.width, m_testParams.height));
	const std::vector<VkRect2D>		scissors			(1, makeRect2D(m_testParams.width, m_testParams.height));

	return vk::makeGraphicsPipeline	(vkd,
									 device,
									 *m_pipelineLayout,
									 *m_vertShaderModule,
									 *m_tescShaderModule,
									 *m_teseShaderModule,
									 *m_geomShaderModule,
									 *m_fragShaderModule,
									 *m_renderPass,
									 viewports,
									 scissors,
									 topology,
									 0,
									 patchControlPoints);
}

void BindingAcceleratioStructureGraphicsTestInstance::initPipeline (void)
{
	const DeviceInterface&	vkd			= m_context.getDeviceInterface();
	const VkDevice			device		= m_context.getDevice();
	Allocator&				allocator	= m_context.getDefaultAllocator();
	vk::BinaryCollection&	collection	= m_context.getBinaryCollection();
	VkShaderStageFlags		shaders		= static_cast<VkShaderStageFlags>(0);
	deUint32				shaderCount	= 0;

	if (collection.contains("vert")) shaders |= VK_SHADER_STAGE_VERTEX_BIT;
	if (collection.contains("geom")) shaders |= VK_SHADER_STAGE_GEOMETRY_BIT;
	if (collection.contains("tesc")) shaders |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
	if (collection.contains("tese")) shaders |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
	if (collection.contains("frag")) shaders |= VK_SHADER_STAGE_FRAGMENT_BIT;

	for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it)
		shaderCount++;

	if (shaderCount != (deUint32)dePop32(shaders))
		TCU_THROW(InternalError, "Unused shaders detected in the collection");

	if (0 != (shaders & VK_SHADER_STAGE_VERTEX_BIT))					m_vertShaderModule = createShaderModule(vkd, device, collection.get("vert"), 0);
	if (0 != (shaders & VK_SHADER_STAGE_GEOMETRY_BIT))					m_geomShaderModule = createShaderModule(vkd, device, collection.get("geom"), 0);
	if (0 != (shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT))		m_tescShaderModule = createShaderModule(vkd, device, collection.get("tesc"), 0);
	if (0 != (shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))	m_teseShaderModule = createShaderModule(vkd, device, collection.get("tese"), 0);
	if (0 != (shaders & VK_SHADER_STAGE_FRAGMENT_BIT))					m_fragShaderModule = createShaderModule(vkd, device, collection.get("frag"), 0);

	m_framebufferImage		= makeImage				(vkd, device, makeImageCreateInfo(m_framebufferFormat, m_testParams.width, m_testParams.height, 1u, VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT));
	m_framebufferImageAlloc	= bindImage				(vkd, device, allocator, *m_framebufferImage, MemoryRequirement::Any);
	m_framebufferAttachment	= makeImageView			(vkd, device, *m_framebufferImage, VK_IMAGE_VIEW_TYPE_2D, m_framebufferFormat, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
	m_renderPass			= makeRenderPass		(vkd, device, m_framebufferFormat);
	m_framebuffer			= makeFramebuffer		(vkd, device, *m_renderPass, *m_framebufferAttachment, m_testParams.width, m_testParams.height);
	m_pipelineLayout		= makePipelineLayout	(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get());
	m_pipeline				= makeGraphicsPipeline	();

	initVertexBuffer();
}

void BindingAcceleratioStructureGraphicsTestInstance::fillCommandBuffer (VkCommandBuffer	commandBuffer)
{
	const DeviceInterface&	vkd					= m_context.getDeviceInterface();
	const VkDeviceSize		vertexBufferOffset	= 0;

	vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
	vkd.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);

	beginRenderPass(vkd, commandBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, m_testParams.width, m_testParams.height), tcu::UVec4());

	vkd.cmdDraw(commandBuffer, m_vertexCount, 1u, 0u, 0u);

	endRenderPass(vkd, commandBuffer);
}

class BindingAcceleratioStructureComputeTestInstance : public BindingAcceleratioStructureTestInstance
{
public:
									BindingAcceleratioStructureComputeTestInstance	(Context&			context,
																					 const TestParams&	testParams);

	virtual							~BindingAcceleratioStructureComputeTestInstance	() {};

	static void						checkSupport									(Context&			context,
																					 const TestParams&	testParams);
	static void						initPrograms									(SourceCollections&	programCollection,
																					 const TestParams&	testParams);

protected:
	virtual void					initPipeline									(void) override;
	virtual void					fillCommandBuffer								(VkCommandBuffer	commandBuffer) override;

	virtual deUint32				getExtraAccelerationDescriptorCount				(void) override									{ return 0; };
	virtual VkShaderStageFlags		getShaderStageFlags								(void) override									{ return VK_SHADER_STAGE_COMPUTE_BIT; }
	virtual VkPipelineBindPoint		getPipelineBindPoint							(void) override									{ return VK_PIPELINE_BIND_POINT_COMPUTE; };

	Move<VkShaderModule>			m_shaderModule;
};

BindingAcceleratioStructureComputeTestInstance::BindingAcceleratioStructureComputeTestInstance (Context&			context,
																								const TestParams&	testParams)
	: BindingAcceleratioStructureTestInstance	(context, testParams)
	, m_shaderModule	()
{
}

void BindingAcceleratioStructureComputeTestInstance::checkSupport (Context&				context,
																   const TestParams&	testParams)
{
	DE_UNREF(context);
	DE_UNREF(testParams);
}

void BindingAcceleratioStructureComputeTestInstance::initPrograms (SourceCollections&	programCollection,
																   const TestParams&	testParams)
{
	const vk::ShaderBuildOptions	buildOptions		(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
	const std::string				testShaderBody		= testParams.testConfigShaderBodyText(testParams);
	const std::string				testBody			=
		"  ivec3       pos      = ivec3(gl_WorkGroupID);\n"
		"  ivec3       size     = ivec3(gl_NumWorkGroups);\n"
		+ testShaderBody;

	switch (testParams.stage)
	{
		case VK_SHADER_STAGE_COMPUTE_BIT:
		{
			std::stringstream css;
			css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
				<< "#extension GL_EXT_ray_query : require\n"
				<< "\n"
				<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
				<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
				<< "\n"
				<< "void main()\n"
				<< "{\n"
				<< testBody
				<< "}\n";

			programCollection.glslSources.add("comp") << glu::ComputeSource(css.str()) << buildOptions;

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown stage");
	}
}

void BindingAcceleratioStructureComputeTestInstance::initPipeline (void)
{
	const DeviceInterface&	vkd			= m_context.getDeviceInterface();
	const VkDevice			device		= m_context.getDevice();
	vk::BinaryCollection&	collection	= m_context.getBinaryCollection();

	m_shaderModule		= createShaderModule(vkd, device, collection.get("comp"), 0);
	m_pipelineLayout	= makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get());
	m_pipeline			= makeComputePipeline(vkd, device, *m_pipelineLayout, *m_shaderModule);
}

void BindingAcceleratioStructureComputeTestInstance::fillCommandBuffer (VkCommandBuffer	commandBuffer)
{
	const DeviceInterface&	vkd	= m_context.getDeviceInterface();

	vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, m_pipeline.get());

	vkd.cmdDispatch(commandBuffer, m_testParams.width, m_testParams.height, 1);
}

class BindingAcceleratioStructureRayTracingTestInstance : public BindingAcceleratioStructureTestInstance
{
public:
													BindingAcceleratioStructureRayTracingTestInstance	(Context&							context,
																										 const TestParams&					testParams);
	virtual											~BindingAcceleratioStructureRayTracingTestInstance	() {};

	static void										checkSupport										(Context&							context,
																										 const TestParams&					testParams);
	static void										initPrograms										(SourceCollections&					programCollection,
																										 const TestParams&					testParams);

protected:
	virtual void									initPipeline										(void) override;
	virtual void									fillCommandBuffer									(VkCommandBuffer					commandBuffer) override;

	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);

	virtual deUint32								getExtraAccelerationDescriptorCount					(void) override													{ return 1; };
	virtual VkShaderStageFlags						getShaderStageFlags									(void) override													{ return ALL_RAY_TRACING_STAGES; }
	virtual VkPipelineBindPoint						getPipelineBindPoint								(void) override													{ return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };

	deUint32										m_shaders;
	deUint32										m_raygenShaderGroup;
	deUint32										m_missShaderGroup;
	deUint32										m_hitShaderGroup;
	deUint32										m_callableShaderGroup;
	deUint32										m_shaderGroupCount;

	Move<VkDescriptorSetLayout>						m_descriptorSetLayoutSvc;
	Move<VkDescriptorSet>							m_descriptorSetSvc;

	de::MovePtr<RayTracingPipeline>					m_rayTracingPipeline;

	de::MovePtr<BufferWithMemory>					m_raygenShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_hitShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_missShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_callableShaderBindingTable;

	VkStridedDeviceAddressRegionKHR					m_raygenShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_missShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_hitShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_callableShaderBindingTableRegion;

	de::SharedPtr<BottomLevelAccelerationStructure>	m_bottomLevelAccelerationStructure;
	de::SharedPtr<TopLevelAccelerationStructure>	m_topLevelAccelerationStructure;
};

BindingAcceleratioStructureRayTracingTestInstance::BindingAcceleratioStructureRayTracingTestInstance (Context&			context,
																									  const TestParams&	testParams)
	: BindingAcceleratioStructureTestInstance	(context, testParams)
	, m_shaders									(0)
	, m_raygenShaderGroup						(~0u)
	, m_missShaderGroup							(~0u)
	, m_hitShaderGroup							(~0u)
	, m_callableShaderGroup						(~0u)
	, m_shaderGroupCount						(0)

	, m_descriptorSetLayoutSvc					()
	, m_descriptorSetSvc						()

	, m_rayTracingPipeline						()

	, m_raygenShaderBindingTable				()
	, m_hitShaderBindingTable					()
	, m_missShaderBindingTable					()
	, m_callableShaderBindingTable				()

	, m_raygenShaderBindingTableRegion			()
	, m_missShaderBindingTableRegion			()
	, m_hitShaderBindingTableRegion				()
	, m_callableShaderBindingTableRegion		()

	, m_bottomLevelAccelerationStructure		()
	, m_topLevelAccelerationStructure			()
{
}

void BindingAcceleratioStructureRayTracingTestInstance::checkSupport (Context&			context,
																	  const TestParams&	testParams)
{
	DE_UNREF(testParams);

	context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");

	const VkPhysicalDeviceRayTracingPipelineFeaturesKHR&	rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();

	if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
		TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
}

void BindingAcceleratioStructureRayTracingTestInstance::initPrograms (SourceCollections&	programCollection,
																	  const TestParams&		testParams)
{
	const vk::ShaderBuildOptions	buildOptions				(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
	const std::string				testShaderBody				= testParams.testConfigShaderBodyText(testParams);
	const std::string				testBody					=
		"  ivec3       pos      = ivec3(gl_LaunchIDEXT);\n"
		"  ivec3       size     = ivec3(gl_LaunchSizeEXT);\n"
		+ testShaderBody;
	const std::string				commonRayGenerationShader	=
		std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
		"#extension GL_EXT_ray_tracing : require\n"
		"\n"
		"layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
		"layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
		"\n"
		"void main()\n"
		"{\n"
		"  uint  rayFlags = 0;\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 (testParams.stage)
	{
		case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
		{
			std::stringstream css;
			css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
				<< "#extension GL_EXT_ray_tracing : require\n"
				<< "#extension GL_EXT_ray_query : require\n"
				<< "\n"
				<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
				<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
				<< "\n"
				<< "void main()\n"
				<< "{\n"
				<< testBody
				<< "}\n";

			programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "hitAttributeEXT vec3 attribs;\n"
					<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testBody
					<< "}\n";

				programCollection.glslSources.add("ahit") << glu::AnyHitSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
					<< "hitAttributeEXT vec3 attribs;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testBody
					<< "}\n";

				programCollection.glslSources.add("chit") << glu::ClosestHitSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "hitAttributeEXT vec3 hitAttribute;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testBody
					<< "  hitAttribute = vec3(0.0f, 0.0f, 0.0f);\n"
					<< "  reportIntersectionEXT(1.0f, 0);\n"
					<< "}\n";

				programCollection.glslSources.add("sect") << glu::IntersectionSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_MISS_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testBody
					<< "}\n";

				programCollection.glslSources.add("miss") << glu::MissSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
		{
			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "\n"
					<< "layout(location = 0) callableDataEXT float dummy;"
					<< "layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< "  executeCallableEXT(0, 0);\n"
					<< "}\n";

				programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;
			}

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "#extension GL_EXT_ray_query : require\n"
					<< "layout(location = 0) callableDataInEXT float dummy;"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testBody
					<< "}\n";

				programCollection.glslSources.add("call") << glu::CallableSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown stage");
	}
}

void BindingAcceleratioStructureRayTracingTestInstance::initPipeline (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();
	vk::BinaryCollection&		collection				= m_context.getBinaryCollection();
	Allocator&					allocator				= m_context.getDefaultAllocator();
	const deUint32				shaderGroupHandleSize	= getShaderGroupHandleSize(vki, physicalDevice);
	const VkShaderStageFlags	hitStages				= VK_SHADER_STAGE_ANY_HIT_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
	deUint32					shaderCount				= 0;

	m_shaderGroupCount = 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		= m_shaderGroupCount++;

	if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR))
		m_missShaderGroup		= m_shaderGroupCount++;

	if (0 != (m_shaders & hitStages))
		m_hitShaderGroup		= m_shaderGroupCount++;

	if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR))
		m_callableShaderGroup	= m_shaderGroupCount++;

	m_rayTracingPipeline		= de::newMovePtr<RayTracingPipeline>();

	m_descriptorSetLayoutSvc	= DescriptorSetLayoutBuilder()
									.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES)
									.build(vkd, device);
	m_descriptorSetSvc			= makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutSvc);

	if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR			, createShaderModule(vkd, device, collection.get("rgen"), 0), m_raygenShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_ANY_HIT_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR			, createShaderModule(vkd, device, collection.get("ahit"), 0), m_hitShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR))		m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR		, createShaderModule(vkd, device, collection.get("chit"), 0), m_hitShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR			, createShaderModule(vkd, device, collection.get("miss"), 0), m_missShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_INTERSECTION_BIT_KHR))	m_rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR	, createShaderModule(vkd, device, collection.get("sect"), 0), m_hitShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR))		m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CALLABLE_BIT_KHR		, createShaderModule(vkd, device, collection.get("call"), 0), m_callableShaderGroup);

	m_pipelineLayout					= makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get(), m_descriptorSetLayoutSvc.get());
	m_pipeline							= m_rayTracingPipeline->createPipeline(vkd, device, *m_pipelineLayout);

	m_raygenShaderBindingTable			= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_raygenShaderGroup);
	m_missShaderBindingTable			= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_missShaderGroup);
	m_hitShaderBindingTable				= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_hitShaderGroup);
	m_callableShaderBindingTable		= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_callableShaderGroup);

	m_raygenShaderBindingTableRegion	= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_raygenShaderBindingTable),		shaderGroupHandleSize, 1);
	m_missShaderBindingTableRegion		= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_missShaderBindingTable),		shaderGroupHandleSize, 1);
	m_hitShaderBindingTableRegion		= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_hitShaderBindingTable),			shaderGroupHandleSize, 1);
	m_callableShaderBindingTableRegion	= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_callableShaderBindingTable),	shaderGroupHandleSize, 1);
}

void BindingAcceleratioStructureRayTracingTestInstance::fillCommandBuffer (VkCommandBuffer	commandBuffer)
{
	const DeviceInterface&							vkd									= m_context.getDeviceInterface();
	const VkDevice									device								= m_context.getDevice();
	Allocator&										allocator							= m_context.getDefaultAllocator();
	de::MovePtr<BottomLevelAccelerationStructure>	bottomLevelAccelerationStructure	= makeBottomLevelAccelerationStructure();
	de::MovePtr<TopLevelAccelerationStructure>		topLevelAccelerationStructure		= makeTopLevelAccelerationStructure();

	m_bottomLevelAccelerationStructure = de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release());
	m_bottomLevelAccelerationStructure->setDefaultGeometryData(m_testParams.stage);
	m_bottomLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);

	m_topLevelAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(topLevelAccelerationStructure.release());
	m_topLevelAccelerationStructure->setInstanceCount(1);
	m_topLevelAccelerationStructure->addInstance(m_bottomLevelAccelerationStructure);
	m_topLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);

	const TopLevelAccelerationStructure*				topLevelAccelerationStructurePtr		= m_topLevelAccelerationStructure.get();
	const VkWriteDescriptorSetAccelerationStructureKHR	accelerationStructureWriteDescriptorSet	= makeWriteDescriptorSetAccelerationStructureKHR(topLevelAccelerationStructurePtr->getPtr());

	DescriptorSetUpdateBuilder()
		.writeSingle(*m_descriptorSetSvc, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet)
		.update(vkd, device);

	vkd.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *m_pipelineLayout, 2, 1, &m_descriptorSetSvc.get(), 0, DE_NULL);

	vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, m_pipeline.get());

	cmdTraceRays(vkd,
		commandBuffer,
		&m_raygenShaderBindingTableRegion,
		&m_missShaderBindingTableRegion,
		&m_hitShaderBindingTableRegion,
		&m_callableShaderBindingTableRegion,
		m_testParams.width, m_testParams.height, 1);
}

de::MovePtr<BufferWithMemory> BindingAcceleratioStructureRayTracingTestInstance::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		= getShaderGroupHandleSize(vki, physicalDevice);
		const deUint32	shaderGroupBaseAlignment	= getShaderGroupBaseAlignment(vki, physicalDevice);

		shaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, group, 1u);
	}

	return shaderBindingTable;
}


class BindingAcceleratioStructureRayTracingRayTracingTestInstance : public BindingAcceleratioStructureTestInstance
{
public:
													BindingAcceleratioStructureRayTracingRayTracingTestInstance		(Context&							context,
																													 const TestParams&					testParams);
	virtual											~BindingAcceleratioStructureRayTracingRayTracingTestInstance	() {};

	static void										checkSupport													(Context&							context,
																													 const TestParams&					testParams);
	static void										initPrograms													(SourceCollections&					programCollection,
																													 const TestParams&					testParams);

protected:
	virtual void									initPipeline													(void) override;
	virtual void									fillCommandBuffer												(VkCommandBuffer					commandBuffer) override;

	void											calcShaderGroup													(deUint32&							shaderGroupCounter,
																													 const VkShaderStageFlags			shaders1,
																													 const VkShaderStageFlags			shaders2,
																													 const VkShaderStageFlags			shaderStageFlags,
																													 deUint32&							shaderGroup,
																													 deUint32&							shaderGroupCount) const;


	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,
																													 const deUint32						groupCount = 1);

	virtual deUint32								getExtraAccelerationDescriptorCount								(void) override													{ return 1; };
	virtual VkShaderStageFlags						getShaderStageFlags												(void) override													{ return ALL_RAY_TRACING_STAGES; }
	virtual VkPipelineBindPoint						getPipelineBindPoint											(void) override													{ return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };

	deUint32										m_shaders;
	deUint32										m_raygenShaderGroup;
	deUint32										m_missShaderGroup;
	deUint32										m_hitShaderGroup;
	deUint32										m_callableShaderGroup;
	deUint32										m_shaderGroupCount;

	Move<VkDescriptorSetLayout>						m_descriptorSetLayoutSvc;
	Move<VkDescriptorSet>							m_descriptorSetSvc;

	de::MovePtr<RayTracingPipeline>					m_rayTracingPipeline;

	de::MovePtr<BufferWithMemory>					m_raygenShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_hitShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_missShaderBindingTable;
	de::MovePtr<BufferWithMemory>					m_callableShaderBindingTable;

	VkStridedDeviceAddressRegionKHR					m_raygenShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_missShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_hitShaderBindingTableRegion;
	VkStridedDeviceAddressRegionKHR					m_callableShaderBindingTableRegion;

	de::SharedPtr<BottomLevelAccelerationStructure>	m_bottomLevelAccelerationStructure;
	de::SharedPtr<TopLevelAccelerationStructure>	m_topLevelAccelerationStructure;
};

BindingAcceleratioStructureRayTracingRayTracingTestInstance::BindingAcceleratioStructureRayTracingRayTracingTestInstance (Context&			context,
																														  const TestParams&	testParams)
	: BindingAcceleratioStructureTestInstance	(context, testParams)
	, m_shaders									(0)
	, m_raygenShaderGroup						(~0u)
	, m_missShaderGroup							(~0u)
	, m_hitShaderGroup							(~0u)
	, m_callableShaderGroup						(~0u)
	, m_shaderGroupCount						(0)

	, m_descriptorSetLayoutSvc					()
	, m_descriptorSetSvc						()

	, m_rayTracingPipeline						()

	, m_raygenShaderBindingTable				()
	, m_hitShaderBindingTable					()
	, m_missShaderBindingTable					()
	, m_callableShaderBindingTable				()

	, m_raygenShaderBindingTableRegion			()
	, m_missShaderBindingTableRegion			()
	, m_hitShaderBindingTableRegion				()
	, m_callableShaderBindingTableRegion		()

	, m_bottomLevelAccelerationStructure		()
	, m_topLevelAccelerationStructure			()
{
}

void BindingAcceleratioStructureRayTracingRayTracingTestInstance::checkSupport (Context&			context,
																				const TestParams&	testParams)
{
	DE_UNREF(testParams);

	context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");

	const VkPhysicalDeviceRayTracingPipelineFeaturesKHR&	rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();

	if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
		TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
}

void BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPrograms (SourceCollections&	programCollection,
																				const TestParams&	testParams)
{
	const vk::ShaderBuildOptions	buildOptions				(programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
	const std::string				testShaderBody				= testParams.testConfigShaderBodyText(testParams);
	const std::string				testBody					=
		"  ivec3       pos      = ivec3(gl_LaunchIDEXT);\n"
		"  ivec3       size     = ivec3(gl_LaunchSizeEXT);\n"
		+ testShaderBody;
	const std::string				testOutClosestHitShader		=
		std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
		"#extension GL_EXT_ray_tracing : require\n"
		"\n"
		"hitAttributeEXT vec3 attribs;\n"
		"layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
		"layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
		"\n"
		"void main()\n"
		"{\n"
		+ testBody +
		"}\n";
	const std::string				testInShaderFragment		=
		"  uint  rayFlags = 0;\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"
		"\n"
		"  traceRayEXT(topLevelAS, rayFlags, cullMask, 1, 0, 1, origin, tmin, direct, tmax, 0);\n";
	const std::string				commonRayGenerationShader	=
		std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
		"#extension GL_EXT_ray_tracing : require\n"
		"\n"
		"layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
		"layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
		"layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
		"\n"
		"void main()\n"
		"{\n"
		"  uint  rayFlags = 0;\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"
		"\n"
		"  traceRayEXT(topLevelAS, rayFlags, cullMask, 0, 0, 0, origin, tmin, direct, tmax, 0);\n"
		"}\n";

	programCollection.glslSources.add("chit0") << glu::ClosestHitSource(testOutClosestHitShader) << buildOptions;
	programCollection.glslSources.add("ahit0") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
	programCollection.glslSources.add("miss0") << glu::MissSource(getMissPassthrough()) << buildOptions;

	switch (testParams.stage)
	{
		case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
		{
			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "\n"
					<< "layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testInShaderFragment
					<< "}\n";

				programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "\n"
					<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
					<< "hitAttributeEXT vec3 attribs;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testInShaderFragment
					<< "}\n";

				programCollection.glslSources.add("chit") << glu::ClosestHitSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;

			break;
		}

		case VK_SHADER_STAGE_MISS_BIT_KHR:
		{
			programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;

			{
				std::stringstream css;
				css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
					<< "#extension GL_EXT_ray_tracing : require\n"
					<< "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
					<< "\n"
					<< "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
					<< "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
					<< "\n"
					<< "void main()\n"
					<< "{\n"
					<< testInShaderFragment
					<< "}\n";

				programCollection.glslSources.add("miss") << glu::MissSource(css.str()) << buildOptions;
			}

			programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
			programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown stage");
	}
}

void BindingAcceleratioStructureRayTracingRayTracingTestInstance::calcShaderGroup (deUint32&				shaderGroupCounter,
																				   const VkShaderStageFlags	shaders1,
																				   const VkShaderStageFlags	shaders2,
																				   const VkShaderStageFlags	shaderStageFlags,
																				   deUint32&				shaderGroup,
																				   deUint32&				shaderGroupCount) const
{
	const deUint32	shader1Count = ((shaders1 & shaderStageFlags) != 0) ? 1 : 0;
	const deUint32	shader2Count = ((shaders2 & shaderStageFlags) != 0) ? 1 : 0;

	shaderGroupCount = shader1Count + shader2Count;

	if (shaderGroupCount != 0)
	{
		shaderGroup			= shaderGroupCounter;
		shaderGroupCounter += shaderGroupCount;
	}
}

void BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPipeline (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();
	vk::BinaryCollection&		collection				= m_context.getBinaryCollection();
	Allocator&					allocator				= m_context.getDefaultAllocator();
	const deUint32				shaderGroupHandleSize	= getShaderGroupHandleSize(vki, physicalDevice);
	const VkShaderStageFlags	hitStages				= VK_SHADER_STAGE_ANY_HIT_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
	deUint32					shaderCount				= 0;
	VkShaderStageFlags			shaders0				= static_cast<VkShaderStageFlags>(0);
	deUint32					raygenShaderGroupCount	= 0;
	deUint32					hitShaderGroupCount		= 0;
	deUint32					missShaderGroupCount	= 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("ahit0")) shaders0 |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
	if (collection.contains("chit0")) shaders0 |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
	if (collection.contains("miss0")) shaders0 |= VK_SHADER_STAGE_MISS_BIT_KHR;

	for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it)
		shaderCount++;

	if (shaderCount != (deUint32)(dePop32(m_shaders) + dePop32(shaders0)))
		TCU_THROW(InternalError, "Unused shaders detected in the collection");

	calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, VK_SHADER_STAGE_RAYGEN_BIT_KHR, m_raygenShaderGroup, raygenShaderGroupCount);
	calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, VK_SHADER_STAGE_MISS_BIT_KHR,   m_missShaderGroup,   missShaderGroupCount);
	calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, hitStages,                      m_hitShaderGroup,    hitShaderGroupCount);

	m_rayTracingPipeline		= de::newMovePtr<RayTracingPipeline>();

	m_descriptorSetLayoutSvc	= DescriptorSetLayoutBuilder()
									.addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES)
									.build(vkd, device);
	m_descriptorSetSvc			= makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutSvc);

	if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR			, createShaderModule(vkd, device, collection.get("rgen"), 0), m_raygenShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_ANY_HIT_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR			, createShaderModule(vkd, device, collection.get("ahit"), 0), m_hitShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR))		m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR		, createShaderModule(vkd, device, collection.get("chit"), 0), m_hitShaderGroup);
	if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR			, createShaderModule(vkd, device, collection.get("miss"), 0), m_missShaderGroup);

	// The "chit" and "miss" cases both generate more rays from their shaders.
	if (m_testParams.testType == TEST_TYPE_USING_RAY_TRACING && (m_testParams.stage == VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR || m_testParams.stage == VK_SHADER_STAGE_MISS_BIT_KHR))
		m_rayTracingPipeline->setMaxRecursionDepth(2u);

	if (0 != (shaders0 & VK_SHADER_STAGE_ANY_HIT_BIT_KHR))			m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR			, createShaderModule(vkd, device, collection.get("ahit0"), 0), m_hitShaderGroup + 1);
	if (0 != (shaders0 & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR))		m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR		, createShaderModule(vkd, device, collection.get("chit0"), 0), m_hitShaderGroup + 1);
	if (0 != (shaders0 & VK_SHADER_STAGE_MISS_BIT_KHR))				m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR			, createShaderModule(vkd, device, collection.get("miss0"), 0), m_missShaderGroup + 1);

	m_pipelineLayout					= makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get(), m_descriptorSetLayoutSvc.get());
	m_pipeline							= m_rayTracingPipeline->createPipeline(vkd, device, *m_pipelineLayout);

	m_raygenShaderBindingTable			= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_raygenShaderGroup,   raygenShaderGroupCount);
	m_missShaderBindingTable			= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_missShaderGroup,     missShaderGroupCount);
	m_hitShaderBindingTable				= createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_hitShaderGroup,      hitShaderGroupCount);

	m_raygenShaderBindingTableRegion	= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_raygenShaderBindingTable),	shaderGroupHandleSize, raygenShaderGroupCount);
	m_missShaderBindingTableRegion		= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_missShaderBindingTable),	shaderGroupHandleSize, missShaderGroupCount);
	m_hitShaderBindingTableRegion		= makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_hitShaderBindingTable),		shaderGroupHandleSize, hitShaderGroupCount);
	m_callableShaderBindingTableRegion	= makeStridedDeviceAddressRegion(vkd, device, DE_NULL, 0, 0);
}

void BindingAcceleratioStructureRayTracingRayTracingTestInstance::fillCommandBuffer (VkCommandBuffer	commandBuffer)
{
	const DeviceInterface&							vkd									= m_context.getDeviceInterface();
	const VkDevice									device								= m_context.getDevice();
	Allocator&										allocator							= m_context.getDefaultAllocator();
	de::MovePtr<BottomLevelAccelerationStructure>	bottomLevelAccelerationStructure	= makeBottomLevelAccelerationStructure();
	de::MovePtr<TopLevelAccelerationStructure>		topLevelAccelerationStructure		= makeTopLevelAccelerationStructure();

	m_bottomLevelAccelerationStructure = de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release());
	m_bottomLevelAccelerationStructure->setDefaultGeometryData(m_testParams.stage);
	m_bottomLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);

	m_topLevelAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(topLevelAccelerationStructure.release());
	m_topLevelAccelerationStructure->setInstanceCount(1);
	m_topLevelAccelerationStructure->addInstance(m_bottomLevelAccelerationStructure);
	m_topLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);

	const TopLevelAccelerationStructure*				topLevelAccelerationStructurePtr		= m_topLevelAccelerationStructure.get();
	const VkWriteDescriptorSetAccelerationStructureKHR	accelerationStructureWriteDescriptorSet	= makeWriteDescriptorSetAccelerationStructureKHR(topLevelAccelerationStructurePtr->getPtr());

	DescriptorSetUpdateBuilder()
		.writeSingle(*m_descriptorSetSvc, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet)
		.update(vkd, device);

	vkd.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *m_pipelineLayout, 2, 1, &m_descriptorSetSvc.get(), 0, DE_NULL);

	vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, m_pipeline.get());

	cmdTraceRays(vkd,
		commandBuffer,
		&m_raygenShaderBindingTableRegion,
		&m_missShaderBindingTableRegion,
		&m_hitShaderBindingTableRegion,
		&m_callableShaderBindingTableRegion,
		m_testParams.width, m_testParams.height, 1);
}

de::MovePtr<BufferWithMemory> BindingAcceleratioStructureRayTracingRayTracingTestInstance::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,
																													 const deUint32						groupCount)
{
	de::MovePtr<BufferWithMemory>	shaderBindingTable;

	if (group < m_shaderGroupCount)
	{
		const deUint32	shaderGroupHandleSize		= getShaderGroupHandleSize(vki, physicalDevice);
		const deUint32	shaderGroupBaseAlignment	= getShaderGroupBaseAlignment(vki, physicalDevice);

		shaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, group, groupCount);
	}

	return shaderBindingTable;
}


const std::string getRayQueryShaderBodyText (const TestParams& testParams)
{
	DE_UNREF(testParams);

	const std::string result =
		"  const float mult     = " + de::toString(FIXED_POINT_DIVISOR) + ".0f;\n"
		"  uint        rayFlags = 0;\n"
		"  uint        cullMask = 0xFF;\n"
		"  float       tmin     = 0.0;\n"
		"  float       tmax     = 9.0;\n"
		"  vec3        origin   = vec3((float(pos.x) + 0.5f) / float(size.x), (float(pos.y) + 0.5f) / float(size.y), 0.0);\n"
		"  vec3        direct   = vec3(0.0, 0.0, 1.0);\n"
		"  int         value    = 0;\n"
		"  rayQueryEXT rayQuery;\n"
		"\n"
		"  rayQueryInitializeEXT(rayQuery, tlas, rayFlags, cullMask, origin, tmin, direct, tmax);\n"
		"\n"
		"  while(rayQueryProceedEXT(rayQuery))\n"
		"  {\n"
		"    if (rayQueryGetIntersectionTypeEXT(rayQuery, false) == gl_RayQueryCandidateIntersectionTriangleEXT)\n"
		"    {\n"
		"      const float t = rayQueryGetIntersectionTEXT(rayQuery, false);"
		"\n"
		"      value = int(round(mult * t));\n"
		"    }\n"
		"  }\n"
		"\n"
		"  imageStore(result, pos, ivec4(value, 0, 0, 0));\n";

	return result;
}

const std::string getRayTracingShaderBodyText (const TestParams& testParams)
{
	DE_UNREF(testParams);

	const std::string result =
		"  const float mult     = " + de::toString(FIXED_POINT_DIVISOR) + ".0f;\n"
		"  int         value    = int(round(mult * gl_HitTEXT));\n"
		"\n"
		"  imageStore(result, pos, ivec4(value, 0, 0, 0));\n";

	return result;
}

class BindingAccelerationStructureTestCase : public TestCase
{
	public:
							BindingAccelerationStructureTestCase	(tcu::TestContext& context, const char* name, const char* desc, const TestParams testParams);
							~BindingAccelerationStructureTestCase	(void);

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

private:
	TestParams				m_testParams;
};

BindingAccelerationStructureTestCase::BindingAccelerationStructureTestCase (tcu::TestContext& context, const char* name, const char* desc, const TestParams testParams)
	: vkt::TestCase	(context, name, desc)
	, m_testParams		(testParams)
{
}

BindingAccelerationStructureTestCase::~BindingAccelerationStructureTestCase (void)
{
}

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

	const VkPhysicalDeviceAccelerationStructureFeaturesKHR&	accelerationStructureFeaturesKHR	= context.getAccelerationStructureFeatures();
	if (accelerationStructureFeaturesKHR.accelerationStructure == DE_FALSE)
		TCU_THROW(TestError, "Requires VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure");

	switch (m_testParams.testType)
	{
		case TEST_TYPE_USING_RAY_QUERY:
		{
			context.requireDeviceFunctionality("VK_KHR_ray_query");

			const VkPhysicalDeviceRayQueryFeaturesKHR&	rayQueryFeaturesKHR	= context.getRayQueryFeatures();

			if (rayQueryFeaturesKHR.rayQuery == DE_FALSE)
				TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayQueryFeaturesKHR.rayQuery");

			break;
		}

		case TEST_TYPE_USING_RAY_TRACING:
		{
			context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");

			const VkPhysicalDeviceRayTracingPipelineFeaturesKHR&	rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();

			if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
				TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown test type");
	}

	switch (m_testParams.updateMethod)
	{
		case UPDATE_METHOD_NORMAL:
		{
			break;
		}

		case UPDATE_METHOD_WITH_TEMPLATE:
		{
			context.requireDeviceFunctionality("VK_KHR_descriptor_update_template");

			break;
		}

		case UPDATE_METHOD_WITH_PUSH:
		{
			context.requireDeviceFunctionality("VK_KHR_push_descriptor");

			break;
		}

		case UPDATE_METHOD_WITH_PUSH_TEMPLATE:
		{
			context.requireDeviceFunctionality("VK_KHR_push_descriptor");
			context.requireDeviceFunctionality("VK_KHR_descriptor_update_template");

			break;
		}

		default:
			TCU_THROW(InternalError, "Unknown update method");
	}

	m_testParams.pipelineCheckSupport(context, m_testParams);
}

TestInstance* BindingAccelerationStructureTestCase::createInstance (Context& context) const
{
	switch (m_testParams.testType)
	{
		case TEST_TYPE_USING_RAY_QUERY:
		{
			switch (m_testParams.stage)
			{
				case VK_SHADER_STAGE_VERTEX_BIT:
				case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
				case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
				case VK_SHADER_STAGE_GEOMETRY_BIT:
				case VK_SHADER_STAGE_FRAGMENT_BIT:
				{
					return new BindingAcceleratioStructureGraphicsTestInstance(context, m_testParams);
				}

				case VK_SHADER_STAGE_COMPUTE_BIT:
				{
					return new BindingAcceleratioStructureComputeTestInstance(context, m_testParams);
				}

				case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
				case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
				case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
				case VK_SHADER_STAGE_MISS_BIT_KHR:
				case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
				case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
				{
					return new BindingAcceleratioStructureRayTracingTestInstance(context, m_testParams);
				}

				default:
					TCU_THROW(InternalError, "Unknown shader stage");
			}
		}

		case TEST_TYPE_USING_RAY_TRACING:
		{
			return new BindingAcceleratioStructureRayTracingRayTracingTestInstance(context, m_testParams);
		}

		default:
			TCU_THROW(InternalError, "Unknown shader stage");
	}
}

void BindingAccelerationStructureTestCase::initPrograms (SourceCollections& programCollection) const
{
	m_testParams.pipelineInitPrograms(programCollection, m_testParams);
}

static inline CheckSupportFunc getPipelineRayQueryCheckSupport (const VkShaderStageFlagBits stage)
{
	switch (stage)
	{
		case VK_SHADER_STAGE_VERTEX_BIT:
		case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
		case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
		case VK_SHADER_STAGE_GEOMETRY_BIT:
		case VK_SHADER_STAGE_FRAGMENT_BIT:
			return BindingAcceleratioStructureGraphicsTestInstance::checkSupport;

		case VK_SHADER_STAGE_COMPUTE_BIT:
			return BindingAcceleratioStructureComputeTestInstance::checkSupport;

		case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
		case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
		case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
		case VK_SHADER_STAGE_MISS_BIT_KHR:
		case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
		case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
			return BindingAcceleratioStructureRayTracingTestInstance::checkSupport;

		default:
			TCU_THROW(InternalError, "Unknown shader stage");
	}
}

static inline CheckSupportFunc getPipelineRayTracingCheckSupport (const VkShaderStageFlagBits stage)
{
	DE_UNREF(stage);

	return BindingAcceleratioStructureRayTracingRayTracingTestInstance::checkSupport;
}

static inline InitProgramsFunc getPipelineRayQueryInitPrograms (const VkShaderStageFlagBits stage)
{
	switch (stage)
	{
		case VK_SHADER_STAGE_VERTEX_BIT:
		case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
		case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
		case VK_SHADER_STAGE_GEOMETRY_BIT:
		case VK_SHADER_STAGE_FRAGMENT_BIT:
			return BindingAcceleratioStructureGraphicsTestInstance::initPrograms;

		case VK_SHADER_STAGE_COMPUTE_BIT:
			return BindingAcceleratioStructureComputeTestInstance::initPrograms;

		case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
		case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
		case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
		case VK_SHADER_STAGE_MISS_BIT_KHR:
		case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
		case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
			return BindingAcceleratioStructureRayTracingTestInstance::initPrograms;

		default:
			TCU_THROW(InternalError, "Unknown shader stage");
	}
}

static inline InitProgramsFunc getPipelineRayTracingInitPrograms (const VkShaderStageFlagBits stage)
{
	DE_UNREF(stage);

	return BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPrograms;
}

static inline ShaderBodyTextFunc getShaderBodyTextFunc (const TestType testType)
{
	switch (testType)
	{
		case TEST_TYPE_USING_RAY_QUERY:		return getRayQueryShaderBodyText;	break;
		case TEST_TYPE_USING_RAY_TRACING:	return getRayTracingShaderBodyText;	break;
		default:							TCU_THROW(InternalError, "Unknown test type");
	}
}

}	// anonymous

tcu::TestCaseGroup* createDescriptorUpdateASTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group	(new tcu::TestCaseGroup(testCtx, "acceleration_structure", "Tests acceleration structure descriptor updates"));

	const struct TestTypes
	{
		TestType	testType;
		const char*	name;
	}
	testTypes[] =
	{
		{ TEST_TYPE_USING_RAY_QUERY,	"ray_query"		},
		{ TEST_TYPE_USING_RAY_TRACING,	"ray_tracing"	},
	};
	const struct UpdateMethods
	{
		const UpdateMethod	method;
		const char*			name;
		const char*			description;
	}
	updateMethods[] =
	{
		{ UPDATE_METHOD_NORMAL,				"regular",				"Use regular descriptor updates"		},
		{ UPDATE_METHOD_WITH_TEMPLATE,		"with_template",		"Use descriptor update templates"		},
		{ UPDATE_METHOD_WITH_PUSH,			"with_push",			"Use push descriptor updates"			},
		{ UPDATE_METHOD_WITH_PUSH_TEMPLATE,	"with_push_template",	"Use push descriptor update templates"	},
	};
	const struct PipelineStages
	{
		VkShaderStageFlagBits	stage;
		const char*				name;
		const bool				rayTracing;
	}
	pipelineStages[] =
	{
		{ VK_SHADER_STAGE_VERTEX_BIT,					"vert",	false	},
		{ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,		"tesc",	false	},
		{ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,	"tese",	false	},
		{ VK_SHADER_STAGE_GEOMETRY_BIT,					"geom",	false	},
		{ VK_SHADER_STAGE_FRAGMENT_BIT,					"frag",	false	},
		{ VK_SHADER_STAGE_COMPUTE_BIT,					"comp",	false	},
		{ VK_SHADER_STAGE_RAYGEN_BIT_KHR,				"rgen",	true	},
		{ VK_SHADER_STAGE_ANY_HIT_BIT_KHR,				"ahit",	false	},
		{ VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,			"chit",	true	},
		{ VK_SHADER_STAGE_MISS_BIT_KHR,					"miss",	true	},
		{ VK_SHADER_STAGE_INTERSECTION_BIT_KHR,			"sect",	false	},
		{ VK_SHADER_STAGE_CALLABLE_BIT_KHR,				"call",	false	},
	};

	for (size_t testTypeNdx = 0; testTypeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++testTypeNdx)
	{
		de::MovePtr<tcu::TestCaseGroup>	testTypeGroup		(new tcu::TestCaseGroup(group->getTestContext(), testTypes[testTypeNdx].name, ""));
		const TestType					testType			= testTypes[testTypeNdx].testType;
		const ShaderBodyTextFunc		shaderBodyTextFunc	= getShaderBodyTextFunc(testType);
		const deUint32					imageDepth			= 1;

		for (size_t updateMethodsNdx = 0; updateMethodsNdx < DE_LENGTH_OF_ARRAY(updateMethods); ++updateMethodsNdx)
		{
			de::MovePtr<tcu::TestCaseGroup>	updateMethodsGroup		(new tcu::TestCaseGroup(group->getTestContext(), updateMethods[updateMethodsNdx].name, updateMethods[updateMethodsNdx].description));
			const UpdateMethod				updateMethod			= updateMethods[updateMethodsNdx].method;

			for (size_t pipelineStageNdx = 0; pipelineStageNdx < DE_LENGTH_OF_ARRAY(pipelineStages); ++pipelineStageNdx)
			{
				const VkShaderStageFlagBits	stage					= pipelineStages[pipelineStageNdx].stage;
				const CheckSupportFunc		pipelineCheckSupport	= (testType == TEST_TYPE_USING_RAY_QUERY)
																	? getPipelineRayQueryCheckSupport(stage)
																	: getPipelineRayTracingCheckSupport(stage);
				const InitProgramsFunc		pipelineInitPrograms	= (testType == TEST_TYPE_USING_RAY_QUERY)
																	? getPipelineRayQueryInitPrograms(stage)
																	: getPipelineRayTracingInitPrograms(stage);

				if (testType == TEST_TYPE_USING_RAY_TRACING && !pipelineStages[pipelineStageNdx].rayTracing)
					continue;

				const TestParams	testParams	=
				{
					TEST_WIDTH,				//  deUint32				width;
					TEST_HEIGHT,			//  deUint32				height;
					imageDepth,				//  deUint32				depth;
					testType,				//  TestType				testType;
					updateMethod,			//  UpdateMethod			updateMethod;
					stage,					//  VkShaderStageFlagBits	stage;
					VK_FORMAT_R32_SINT,		//  VkFormat				format;
					pipelineCheckSupport,	//  CheckSupportFunc		pipelineCheckSupport;
					pipelineInitPrograms,	//  InitProgramsFunc		pipelineInitPrograms;
					shaderBodyTextFunc,		//  ShaderTestTextFunc		testConfigShaderBodyText;
				};

				updateMethodsGroup->addChild(new BindingAccelerationStructureTestCase(group->getTestContext(), pipelineStages[pipelineStageNdx].name, "", testParams));
			}

			testTypeGroup->addChild(updateMethodsGroup.release());
		}

		group->addChild(testTypeGroup.release());
	}

	return group.release();
}

}	// RayQuery
}	// vkt