/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2019 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Tests fragment density map extension ( VK_EXT_fragment_density_map )
 *//*--------------------------------------------------------------------*/

#include "vktRenderPassFragmentDensityMapTests.hpp"
#include "pipeline/vktPipelineImageUtil.hpp"
#include "deMath.h"
#include "vktTestCase.hpp"
#include "vkImageUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkObjUtil.hpp"
#include "tcuTestLog.hpp"
#include <sstream>
#include <vector>

// Each test generates an image with a color gradient where all colors should be unique when rendered without density map
// ( the number of each color in a histogram should be 1 ).
// The whole density map has the same values defined by input fragment area ( one of the test input parameters ).
// With density map enabled - the number of each color in a histogram should be [ fragmentArea.x * fragmentArea.y ].
//
// Additionally test checks if gl_FragSizeEXT shader variable has proper value ( as defined by fragmentArea input parameter ).
//
// static_* tests use density map loaded from CPU.
// dynamic_* tests use density map rendered on a GPU in a separate render pass
// *_nonsubsampled tests check if it's possible to use nonsubsampled images instead of subsampled ones
// There are 3 render passes performed during the test:
//  - render pass that produces density map ( this rp is skipped when density map is static )
//  - render pass that produces subsampled image using density map
//  - render pass that copies subsampled image to traditional image using sampler with VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT flag.
//    ( because subsampled images cannot be retrieved to CPU in any other way ).

namespace vkt
{

namespace renderpass
{

using namespace vk;

namespace
{

// set value of DRY_RUN_WITHOUT_FDM_EXTENSION to 1 if you want to check the correctness of the code without using VK_EXT_fragment_density_map extension
#define DRY_RUN_WITHOUT_FDM_EXTENSION 0

struct TestParams
{
	TestParams(bool dynamicDensity, bool nonSubsampled, const tcu::UVec2& area)
		: dynamicDensityMap{ dynamicDensity }, nonSubsampledImages{ nonSubsampled }, fragmentArea{ area }, densityMapFormat{ VK_FORMAT_R8G8_UNORM }
	{}
	bool		dynamicDensityMap;
	bool		nonSubsampledImages;
	tcu::UVec2	fragmentArea;
	VkFormat	densityMapFormat;
};

struct Vertex4RGBA
{
	tcu::Vec4	position;
	tcu::Vec4	color;
};

std::vector<Vertex4RGBA> createFullscreenQuadRG(void)
{
	const Vertex4RGBA lowerLeftVertex	= { tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f),		tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f) };
	const Vertex4RGBA upperLeftVertex	= { tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f),	tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f) };
	const Vertex4RGBA lowerRightVertex	= { tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),		tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f) };
	const Vertex4RGBA upperRightVertex	= { tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f),		tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f) };

	return
	{
		lowerLeftVertex, lowerRightVertex, upperLeftVertex,
		upperLeftVertex, lowerRightVertex, upperRightVertex
	};
}

std::vector<Vertex4RGBA> createFullscreenQuadDensity(float densityX, float densityY)
{
	const Vertex4RGBA lowerLeftVertex	= { tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f),		tcu::Vec4(densityX, densityY, 0.0f, 1.0f) };
	const Vertex4RGBA upperLeftVertex	= { tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f),	tcu::Vec4(densityX, densityY, 0.0f, 1.0f) };
	const Vertex4RGBA lowerRightVertex	= { tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f),		tcu::Vec4(densityX, densityY, 0.0f, 1.0f) };
	const Vertex4RGBA upperRightVertex	= { tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f),		tcu::Vec4(densityX, densityY, 0.0f, 1.0f) };

	return
	{
		lowerLeftVertex, lowerRightVertex, upperLeftVertex,
		upperLeftVertex, lowerRightVertex, upperRightVertex
	};
};

template <typename T>
void createVertexBuffer(const DeviceInterface&		vk,
						VkDevice					vkDevice,
						const deUint32&				queueFamilyIndex,
						SimpleAllocator&			memAlloc,
						const std::vector<T>&		vertices,
						Move<VkBuffer>&				vertexBuffer,
						de::MovePtr<Allocation>&	vertexAlloc)
{
	const VkBufferCreateInfo vertexBufferParams =
	{
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,			// VkStructureType		sType;
		DE_NULL,										// const void*			pNext;
		0u,												// VkBufferCreateFlags	flags;
		(VkDeviceSize)(sizeof(T) * vertices.size()),	// VkDeviceSize			size;
		VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,				// VkBufferUsageFlags	usage;
		VK_SHARING_MODE_EXCLUSIVE,						// VkSharingMode		sharingMode;
		1u,												// deUint32				queueFamilyIndexCount;
		&queueFamilyIndex								// const deUint32*		pQueueFamilyIndices;
	};

	vertexBuffer	= createBuffer(vk, vkDevice, &vertexBufferParams);
	vertexAlloc		= memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
	VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexAlloc->getMemory(), vertexAlloc->getOffset()));

	// Upload vertex data
	deMemcpy(vertexAlloc->getHostPtr(), vertices.data(), vertices.size() * sizeof(T));
	flushAlloc(vk, vkDevice, *vertexAlloc);
}

template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo>
Move<VkRenderPass> createRenderPassProduceDynamicDensityMap(const DeviceInterface&	vk,
															VkDevice				vkDevice,
															const TestParams&		testParams)
{
	VkImageLayout densityPassFinalLayout = testParams.dynamicDensityMap ? VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
	std::vector<AttachmentDesc>		attachmentDescriptions =
	{
		{
			DE_NULL,															// const void*						pNext
			(VkAttachmentDescriptionFlags)0,									// VkAttachmentDescriptionFlags		flags
			testParams.densityMapFormat,										// VkFormat							format
			VK_SAMPLE_COUNT_1_BIT,												// VkSampleCountFlagBits			samples
			VK_ATTACHMENT_LOAD_OP_CLEAR,										// VkAttachmentLoadOp				loadOp
			VK_ATTACHMENT_STORE_OP_STORE,										// VkAttachmentStoreOp				storeOp
			VK_ATTACHMENT_LOAD_OP_DONT_CARE,									// VkAttachmentLoadOp				stencilLoadOp
			VK_ATTACHMENT_STORE_OP_DONT_CARE,									// VkAttachmentStoreOp				stencilStoreOp
			VK_IMAGE_LAYOUT_UNDEFINED,											// VkImageLayout					initialLayout
			densityPassFinalLayout												// VkImageLayout					finalLayout
		}
	};

	std::vector<AttachmentRef> colorAttachmentRefs
	{
		{ DE_NULL, 0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT }
	};

	std::vector<SubpassDesc>	subpassDescriptions
	{
		{
			DE_NULL,
			(VkSubpassDescriptionFlags)0,										// VkSubpassDescriptionFlags		flags
			VK_PIPELINE_BIND_POINT_GRAPHICS,									// VkPipelineBindPoint				pipelineBindPoint
			0u,																	// deUint32							viewMask
			0u,																	// deUint32							inputAttachmentCount
			DE_NULL,															// const VkAttachmentReference*		pInputAttachments
			static_cast<deUint32>(colorAttachmentRefs.size()),					// deUint32							colorAttachmentCount
			colorAttachmentRefs.data(),											// const VkAttachmentReference*		pColorAttachments
			DE_NULL,															// const VkAttachmentReference*		pResolveAttachments
			DE_NULL,															// const VkAttachmentReference*		pDepthStencilAttachment
			0u,																	// deUint32							preserveAttachmentCount
			DE_NULL																// const deUint32*					pPreserveAttachments
		}
	};

	std::vector<SubpassDep>		subpassDependencies;
	if ( testParams.dynamicDensityMap )
	{
		subpassDependencies.emplace_back(
			SubpassDep(
				DE_NULL,														// const void*				pNext
				0u,																// uint32_t					srcSubpass
				VK_SUBPASS_EXTERNAL,											// uint32_t					dstSubpass
				VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,					// VkPipelineStageFlags		srcStageMask
				VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,				// VkPipelineStageFlags		dstStageMask
				VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,							// VkAccessFlags			srcAccessMask
				VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT,					// VkAccessFlags			dstAccessMask
				VK_DEPENDENCY_BY_REGION_BIT,									// VkDependencyFlags		dependencyFlags
				0u																// deInt32					viewOffset
			)
		);
	};

	const RenderPassCreateInfo	renderPassInfo(
		DE_NULL,																// const void*						pNext
		(VkRenderPassCreateFlags)0,												// VkRenderPassCreateFlags			flags
		static_cast<deUint32>(attachmentDescriptions.size()),					// deUint32							attachmentCount
		attachmentDescriptions.data(),											// const VkAttachmentDescription*	pAttachments
		static_cast<deUint32>(subpassDescriptions.size()),						// deUint32							subpassCount
		subpassDescriptions.data(),												// const VkSubpassDescription*		pSubpasses
		static_cast<deUint32>(subpassDependencies.size()),						// deUint32							dependencyCount
		(!testParams.dynamicDensityMap) ? DE_NULL : subpassDependencies.data(),	// const VkSubpassDependency*		pDependencies
		0u,																		// deUint32							correlatedViewMaskCount
		DE_NULL																	// const deUint32*					pCorrelatedViewMasks
	);

	return renderPassInfo.createRenderPass(vk, vkDevice);
}

template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo>
Move<VkRenderPass> createRenderPassProduceSubsampledImage(const DeviceInterface&	vk,
													 VkDevice				vkDevice,
													 const TestParams&		testParams)
{
	DE_UNREF(testParams);
	std::vector<AttachmentDesc>		attachmentDescriptions
	{
		// Output color attachment
		{
			DE_NULL,																// const void*						pNext
			(VkAttachmentDescriptionFlags)0,										// VkAttachmentDescriptionFlags		flags
			VK_FORMAT_R8G8B8A8_UNORM,												// VkFormat							format
			VK_SAMPLE_COUNT_1_BIT,													// VkSampleCountFlagBits			samples
			VK_ATTACHMENT_LOAD_OP_CLEAR,											// VkAttachmentLoadOp				loadOp
			VK_ATTACHMENT_STORE_OP_STORE,											// VkAttachmentStoreOp				storeOp
			VK_ATTACHMENT_LOAD_OP_DONT_CARE,										// VkAttachmentLoadOp				stencilLoadOp
			VK_ATTACHMENT_STORE_OP_DONT_CARE,										// VkAttachmentStoreOp				stencilStoreOp
			VK_IMAGE_LAYOUT_UNDEFINED,												// VkImageLayout					initialLayout
			VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL								// VkImageLayout					finalLayout
		}
	};

#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	{
		attachmentDescriptions.emplace_back(
			AttachmentDesc(
				DE_NULL,															// const void*						pNext
				(VkAttachmentDescriptionFlags)0,									// VkAttachmentDescriptionFlags		flags
				testParams.densityMapFormat,										// VkFormat							format
				VK_SAMPLE_COUNT_1_BIT,												// VkSampleCountFlagBits			samples
				VK_ATTACHMENT_LOAD_OP_LOAD,											// VkAttachmentLoadOp				loadOp
				VK_ATTACHMENT_STORE_OP_DONT_CARE,									// VkAttachmentStoreOp				storeOp
				VK_ATTACHMENT_LOAD_OP_DONT_CARE,									// VkAttachmentLoadOp				stencilLoadOp
				VK_ATTACHMENT_STORE_OP_DONT_CARE,									// VkAttachmentStoreOp				stencilStoreOp
				VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,					// VkImageLayout					initialLayout
				VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT					// VkImageLayout					finalLayout
			)
		);
	}
#endif

	std::vector<AttachmentRef> colorAttachmentRefs
	{
		{ DE_NULL, 0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT }
	};

	std::vector<SubpassDesc>	subpassDescriptions
	{
		{
			DE_NULL,
			(VkSubpassDescriptionFlags)0,											// VkSubpassDescriptionFlags	flags
			VK_PIPELINE_BIND_POINT_GRAPHICS,										// VkPipelineBindPoint			pipelineBindPoint
			0u,																		// deUint32						viewMask
			0u,																		// deUint32						inputAttachmentCount
			DE_NULL,																// const VkAttachmentReference*	pInputAttachments
			static_cast<deUint32>(colorAttachmentRefs.size()),						// deUint32						colorAttachmentCount
			colorAttachmentRefs.data(),												// const VkAttachmentReference*	pColorAttachments
			DE_NULL,																// const VkAttachmentReference*	pResolveAttachments
			DE_NULL,																// const VkAttachmentReference*	pDepthStencilAttachment
			0u,																		// deUint32						preserveAttachmentCount
			DE_NULL																	// const deUint32*				pPreserveAttachments
		}
	};

	std::vector<SubpassDep>		subpassDependencies
	{
		{
			DE_NULL,																// const void*				pNext
			0u,																		// uint32_t					srcSubpass
			VK_SUBPASS_EXTERNAL,													// uint32_t					dstSubpass
			VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,							// VkPipelineStageFlags		srcStageMask
			VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,									// VkPipelineStageFlags		dstStageMask
			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,									// VkAccessFlags			srcAccessMask
			VK_ACCESS_SHADER_READ_BIT,												// VkAccessFlags			dstAccessMask
			VK_DEPENDENCY_BY_REGION_BIT,											// VkDependencyFlags		dependencyFlags
			0u																		// deInt32					viewOffset
		}
	};

	VkRenderPassFragmentDensityMapCreateInfoEXT renderPassFragmentDensityMap;
	renderPassFragmentDensityMap.sType							= VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
	renderPassFragmentDensityMap.pNext							= DE_NULL;
	renderPassFragmentDensityMap.fragmentDensityMapAttachment	= { 1, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT };

#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	const void* renderPassInfoPNext = (const void*)&renderPassFragmentDensityMap;
#else
	const void* renderPassInfoPNext = DE_NULL;
#endif
	const RenderPassCreateInfo	renderPassInfo(
		renderPassInfoPNext,														// const void*						pNext
		(VkRenderPassCreateFlags)0,													// VkRenderPassCreateFlags			flags
		static_cast<deUint32>(attachmentDescriptions.size()),						// deUint32							attachmentCount
		attachmentDescriptions.data(),												// const VkAttachmentDescription*	pAttachments
		static_cast<deUint32>(subpassDescriptions.size()),							// deUint32							subpassCount
		subpassDescriptions.data(),													// const VkSubpassDescription*		pSubpasses
		static_cast<deUint32>(subpassDependencies.size()),							// deUint32							dependencyCount
		subpassDependencies.data(),													// const VkSubpassDependency*		pDependencies
		0u,																			// deUint32							correlatedViewMaskCount
		DE_NULL																		// const deUint32*					pCorrelatedViewMasks
	);

	return renderPassInfo.createRenderPass(vk, vkDevice);
}

template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo>
Move<VkRenderPass> createRenderPassOutputSubsampledImage(const DeviceInterface&	vk,
													VkDevice				vkDevice,
													const TestParams&		testParams)
{
	DE_UNREF(testParams);
	// copy subsampled image to ordinary image - you cannot retrieve subsampled image to CPU in any way. You must first convert it into plain image through rendering
	std::vector<AttachmentDesc>		attachmentDescriptions =
	{
		// output attachment
		AttachmentDesc(
			DE_NULL,											// const void*						pNext
			(VkAttachmentDescriptionFlags)0,					// VkAttachmentDescriptionFlags		flags
			VK_FORMAT_R8G8B8A8_UNORM,							// VkFormat							format
			VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits			samples
			VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				loadOp
			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				storeOp
			VK_ATTACHMENT_LOAD_OP_DONT_CARE,					// VkAttachmentLoadOp				stencilLoadOp
			VK_ATTACHMENT_STORE_OP_DONT_CARE,					// VkAttachmentStoreOp				stencilStoreOp
			VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout					initialLayout
			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL			// VkImageLayout					finalLayout
		),
	};

	std::vector<AttachmentRef> colorAttachmentRefs
	{
		{ DE_NULL, 0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT }
	};

	std::vector<SubpassDesc>	subpassDescriptions =
	{
		{
			DE_NULL,
			(VkSubpassDescriptionFlags)0,						// VkSubpassDescriptionFlags		flags
			VK_PIPELINE_BIND_POINT_GRAPHICS,					// VkPipelineBindPoint				pipelineBindPoint
			0u,													// deUint32							viewMask
			0u,													// deUint32							inputAttachmentCount
			DE_NULL,											// const VkAttachmentReference*		pInputAttachments
			static_cast<deUint32>(colorAttachmentRefs.size()),	// deUint32							colorAttachmentCount
			colorAttachmentRefs.data(),							// const VkAttachmentReference*		pColorAttachments
			DE_NULL,											// const VkAttachmentReference*		pResolveAttachments
			DE_NULL,											// const VkAttachmentReference*		pDepthStencilAttachment
			0u,													// deUint32							preserveAttachmentCount
			DE_NULL												// const deUint32*					pPreserveAttachments
		}
	};

	const RenderPassCreateInfo	renderPassInfo(
		DE_NULL,												// const void*						pNext
		(VkRenderPassCreateFlags)0,								// VkRenderPassCreateFlags			flags
		static_cast<deUint32>(attachmentDescriptions.size()),	// deUint32							attachmentCount
		attachmentDescriptions.data(),							// const VkAttachmentDescription*	pAttachments
		static_cast<deUint32>(subpassDescriptions.size()),		// deUint32							subpassCount
		subpassDescriptions.data(),								// const VkSubpassDescription*		pSubpasses
		0,														// deUint32							dependencyCount
		DE_NULL,												// const VkSubpassDependency*		pDependencies
		0u,														// deUint32							correlatedViewMaskCount
		DE_NULL													// const deUint32*					pCorrelatedViewMasks
	);

	return renderPassInfo.createRenderPass(vk, vkDevice);
}

Move<VkFramebuffer> createFrameBuffer( const DeviceInterface& vk, VkDevice vkDevice, VkRenderPass renderPass, const tcu::UVec2& renderSize, const std::vector<VkImageView>& imageViews)
{
	const VkFramebufferCreateInfo	framebufferParams =
	{
		VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,	// VkStructureType			sType;
		DE_NULL,									// const void*				pNext;
		0u,											// VkFramebufferCreateFlags	flags;
		renderPass,									// VkRenderPass				renderPass;
		static_cast<deUint32>(imageViews.size()),	// deUint32					attachmentCount;
		imageViews.data(),							// const VkImageView*		pAttachments;
		renderSize.x(),								// deUint32					width;
		renderSize.y(),								// deUint32					height;
		1u											// deUint32					layers;
	};

	return createFramebuffer(vk, vkDevice, &framebufferParams);
}

class FragmentDensityMapTest : public vkt::TestCase
{
public:
										FragmentDensityMapTest	(tcu::TestContext&	testContext,
																 const std::string&	name,
																 const std::string&	description,
																 const TestParams&	testParams);
	virtual void						initPrograms			(SourceCollections&	sourceCollections) const;
	virtual TestInstance*				createInstance			(Context&			context) const;
	virtual void						checkSupport			(Context& context) const;

private:
	const TestParams					m_testParams;
};

class FragmentDensityMapTestInstance : public vkt::TestInstance
{
public:
													FragmentDensityMapTestInstance	(Context&				context,
																					 const TestParams&		testParams);
	virtual tcu::TestStatus							iterate							(void);
private:
	tcu::TestStatus									verifyImage						(void);

	TestParams										m_testParams;
	const tcu::UVec2								m_renderSize;
	const tcu::UVec2								m_densityMapSize;

	VkPhysicalDeviceFragmentDensityMapPropertiesEXT	m_fragmentDensityMapProperties;

	Move<VkCommandPool>								m_cmdPool;

	Move<VkImage>									m_densityMapImage;
	de::MovePtr<Allocation>							m_densityMapImageAlloc;
	Move<VkImageView>								m_densityMapImageView;

	Move<VkImage>									m_colorImage;
	de::MovePtr<Allocation>							m_colorImageAlloc;
	Move<VkImageView>								m_colorImageView;

	Move<VkImage>									m_outputImage;
	de::MovePtr<Allocation>							m_outputImageAlloc;
	Move<VkImageView>								m_outputImageView;

	Move<VkSampler>									m_colorSampler;

	Move<VkRenderPass>								m_renderPassProduceDynamicDensityMap;
	Move<VkRenderPass>								m_renderPassProduceSubsampledImage;
	Move<VkRenderPass>								m_renderPassOutputSubsampledImage;
	Move<VkFramebuffer>								m_framebufferProduceDynamicDensityMap;
	Move<VkFramebuffer>								m_framebufferProduceSubsampledImage;
	Move<VkFramebuffer>								m_framebufferOutputSubsampledImage;

	Move<VkDescriptorSetLayout>						m_descriptorSetLayoutProduceSubsampled;
	Move<VkDescriptorSetLayout>						m_descriptorSetLayoutOutputSubsampledImage;
	Move<VkDescriptorPool>							m_descriptorPoolOutputSubsampledImage;
	Move<VkDescriptorSet>							m_descriptorSetOutputSubsampledImage;

	Move<VkShaderModule>							m_vertexCommonShaderModule;
	Move<VkShaderModule>							m_fragmentShaderModuleProduceSubsampledImage;
	Move<VkShaderModule>							m_fragmentShaderModuleOutputSubsampledImage;

	Move<VkBuffer>									m_vertexBuffer;
	std::vector<Vertex4RGBA>						m_vertices;
	de::MovePtr<Allocation>							m_vertexBufferAlloc;

	Move<VkBuffer>									m_vertexBufferDDM;
	std::vector<Vertex4RGBA>						m_verticesDDM;
	de::MovePtr<Allocation>							m_vertexBufferAllocDDM;

	Move<VkPipelineLayout>							m_pipelineLayoutProduceSubsampledImage;
	Move<VkPipelineLayout>							m_pipelineLayoutOutputSubsampledImage;
	Move<VkPipeline>								m_graphicsPipelineProduceDynamicDensityMap;
	Move<VkPipeline>								m_graphicsPipelineProduceSubsampledImage;
	Move<VkPipeline>								m_graphicsPipelineOutputSubsampledImage;

	Move<VkCommandBuffer>							m_cmdBuffer;
};

FragmentDensityMapTest::FragmentDensityMapTest (tcu::TestContext&	testContext,
												const std::string&	name,
												const std::string&	description,
												const TestParams&	testParams)
	: vkt::TestCase	(testContext, name, description)
	, m_testParams	(testParams)
{
}

void FragmentDensityMapTest::initPrograms(SourceCollections& sourceCollections) const
{
	std::ostringstream densityVertexGLSL;
	densityVertexGLSL <<
		"#version 450\n"
		"layout(location = 0) in  vec4 inPosition;\n"
		"layout(location = 1) in  vec4 inColor;\n"
		"layout(location = 0) out vec4 outColor;\n"
		"layout(location = 1) out vec2 outUV;\n"
		"void main(void)\n"
		"{\n"
		"	gl_Position = inPosition;\n"
		"	outColor = inColor;\n"
		"	outUV = 0.5 * inPosition.xy + vec2(0.5);\n"
		"}\n";
	sourceCollections.glslSources.add("densitymap_vert") << glu::VertexSource(densityVertexGLSL.str());

	std::ostringstream densityFragmentProduceGLSL;
	densityFragmentProduceGLSL <<
		"#version 450\n"
		"#extension GL_EXT_fragment_invocation_density : enable\n"
		"layout(location = 0) in  vec4 inColor;\n"
		"layout(location = 1) in  vec2 inUV;\n"
		"layout(location = 0) out vec4 fragColor;\n"
		"void main(void)\n"
		"{\n"
		"	fragColor = vec4(inColor.x, inColor.y, 1.0/float(gl_FragSizeEXT.x), 1.0/(gl_FragSizeEXT.y));\n"
		"}\n";
	sourceCollections.glslSources.add("densitymap_frag_produce") << glu::FragmentSource(densityFragmentProduceGLSL.str());

	std::ostringstream densityFragmentOutputGLSL;
	densityFragmentOutputGLSL <<
		"#version 450\n"
		"layout(location = 0) in vec4 inColor;\n"
		"layout(location = 1) in vec2 inUV;\n"
		"layout(binding = 0)  uniform sampler2D subsampledImage;\n"
		"layout(location = 0) out vec4 fragColor;\n"
		"void main(void)\n"
		"{\n"
		"	fragColor = texture(subsampledImage, inUV);\n"
		"}\n";
	sourceCollections.glslSources.add("densitymap_frag_output") << glu::FragmentSource(densityFragmentOutputGLSL.str());
}

TestInstance* FragmentDensityMapTest::createInstance(Context& context) const
{
	return new FragmentDensityMapTestInstance(context, m_testParams);
}

void FragmentDensityMapTest::checkSupport(Context& context) const
{
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	context.requireDeviceFunctionality("VK_EXT_fragment_density_map");

	VkPhysicalDeviceFeatures2 features;
	deMemset(&features, 0, sizeof(VkPhysicalDeviceFeatures2));
	features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;

	VkPhysicalDeviceFragmentDensityMapFeaturesEXT fragmentDensityMapFeatures;
	deMemset(&fragmentDensityMapFeatures, 0, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT));
	fragmentDensityMapFeatures.sType	= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
	features.pNext						= &fragmentDensityMapFeatures;

	context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &features);

	if (!fragmentDensityMapFeatures.fragmentDensityMap)
		TCU_THROW(NotSupportedError, "fragmentDensityMap feature is not supported");
	if (m_testParams.dynamicDensityMap && !fragmentDensityMapFeatures.fragmentDensityMapDynamic)
		TCU_THROW(NotSupportedError, "fragmentDensityMapDynamic feature is not supported");
	if (m_testParams.nonSubsampledImages && !fragmentDensityMapFeatures.fragmentDensityMapNonSubsampledImages)
		TCU_THROW(NotSupportedError, "fragmentDensityMapNonSubsampledImages feature is not supported");
#else
	DE_UNREF(context);
#endif
}

FragmentDensityMapTestInstance::FragmentDensityMapTestInstance(Context&			context,
															const TestParams&	testParams)
	: vkt::TestInstance	( context )
	, m_testParams		( testParams )
	, m_renderSize		( 32u, 32u )
	, m_densityMapSize	( 16u, 16u )
	, m_vertices		( createFullscreenQuadRG() )
	, m_verticesDDM		( createFullscreenQuadDensity(1.0f / static_cast<float>(testParams.fragmentArea.x()), 1.0f / static_cast<float>(testParams.fragmentArea.y())) )
{
	const DeviceInterface&		vk						= m_context.getDeviceInterface();
	const VkDevice				vkDevice				= m_context.getDevice();
	const deUint32				queueFamilyIndex		= m_context.getUniversalQueueFamilyIndex();
	SimpleAllocator				memAlloc				(vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
	const VkComponentMapping	componentMappingRGBA	= { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };

#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	{
		VkPhysicalDeviceProperties2 properties;
		deMemset(&properties, 0, sizeof(VkPhysicalDeviceProperties2));
		properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;

		deMemset(&m_fragmentDensityMapProperties, 0, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT));
		m_fragmentDensityMapProperties.sType	= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
		properties.pNext						= &m_fragmentDensityMapProperties;

		context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
	}
#else
	{
		m_fragmentDensityMapProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
		m_fragmentDensityMapProperties.minFragmentDensityTexelSize.width	= 1u;
		m_fragmentDensityMapProperties.maxFragmentDensityTexelSize.width	= 1u;
		m_fragmentDensityMapProperties.minFragmentDensityTexelSize.height	= 1u;
		m_fragmentDensityMapProperties.maxFragmentDensityTexelSize.height	= 1u;
		m_fragmentDensityMapProperties.fragmentDensityInvocations			= DE_FALSE;
		m_testParams.fragmentArea.x()										= 1u;
		m_testParams.fragmentArea.y()										= 1u;
	}
#endif

	// Create density map image
	{
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
		vk::VkImageUsageFlags densityMapImageUsage = m_testParams.dynamicDensityMap ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT : VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT;
#else
		vk::VkImageUsageFlags densityMapImageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
#endif
		const VkImageCreateInfo	densityMapImageParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,											// VkStructureType			sType;
			DE_NULL,																		// const void*				pNext;
			0u,																				// VkImageCreateFlags		flags;
			VK_IMAGE_TYPE_2D,																// VkImageType				imageType;
			m_testParams.densityMapFormat,													// VkFormat					format;
			{ m_densityMapSize.x(), m_densityMapSize.y(), 1u },								// VkExtent3D				extent;
			1u,																				// deUint32					mipLevels;
			1u,																				// deUint32					arrayLayers;
			VK_SAMPLE_COUNT_1_BIT,															// VkSampleCountFlagBits	samples;
			VK_IMAGE_TILING_OPTIMAL,														// VkImageTiling			tiling;
			densityMapImageUsage,															// VkImageUsageFlags		usage;
			VK_SHARING_MODE_EXCLUSIVE,														// VkSharingMode			sharingMode;
			1u,																				// deUint32					queueFamilyIndexCount;
			&queueFamilyIndex,																// const deUint32*			pQueueFamilyIndices;
			VK_IMAGE_LAYOUT_UNDEFINED														// VkImageLayout			initialLayout;
		};

		m_densityMapImage = createImage(vk, vkDevice, &densityMapImageParams);

		// Allocate and bind density map image memory
		VkMemoryRequirements			memoryRequirements = getImageMemoryRequirements(vk, vkDevice, *m_densityMapImage);

		m_densityMapImageAlloc = memAlloc.allocate(memoryRequirements, MemoryRequirement::Any);
		VK_CHECK(vk.bindImageMemory(vkDevice, *m_densityMapImage, m_densityMapImageAlloc->getMemory(), m_densityMapImageAlloc->getOffset()));

		// create and fill staging buffer, copy its data to density map image
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
		tcu::TextureFormat	densityMapTextureFormat = vk::mapVkFormat(m_testParams.densityMapFormat);

		if ( !m_testParams.dynamicDensityMap )
		{
			VkDeviceSize stagingBufferSize = tcu::getPixelSize(densityMapTextureFormat) * m_densityMapSize.x() * m_densityMapSize.y() * 1;
			const vk::VkBufferCreateInfo	stagingBufferCreateInfo =
			{
				vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
				DE_NULL,
				0u,									// flags
				stagingBufferSize,					// size
				VK_BUFFER_USAGE_TRANSFER_SRC_BIT,	// usage
				vk::VK_SHARING_MODE_EXCLUSIVE,		// sharingMode
				0u,									// queueFamilyCount
				DE_NULL,							// pQueueFamilyIndices
			};
			vk::Move<vk::VkBuffer>			stagingBuffer		= vk::createBuffer(vk, vkDevice, &stagingBufferCreateInfo);
			const vk::VkMemoryRequirements	stagingRequirements = vk::getBufferMemoryRequirements(vk, vkDevice, *stagingBuffer);
			de::MovePtr<vk::Allocation>		stagingAllocation	= memAlloc.allocate(stagingRequirements, MemoryRequirement::HostVisible);
			VK_CHECK(vk.bindBufferMemory(vkDevice, *stagingBuffer, stagingAllocation->getMemory(), stagingAllocation->getOffset()));
			tcu::PixelBufferAccess			stagingBufferAccess	= tcu::PixelBufferAccess(densityMapTextureFormat, m_densityMapSize.x(), m_densityMapSize.y(), 1, stagingAllocation->getHostPtr());

			tcu::Vec4 fragmentArea { 1.0f / static_cast<float>(testParams.fragmentArea.x()), 1.0f / static_cast<float>(testParams.fragmentArea.y()), 0.0f, 1.0f };
			for (int y = 0; y < stagingBufferAccess.getHeight(); y++)
				for (int x = 0; x < stagingBufferAccess.getWidth(); x++)
					stagingBufferAccess.setPixel(fragmentArea, x, y);
			flushAlloc(vk, vkDevice, *stagingAllocation);

			std::vector<VkBufferImageCopy> copyRegions =
			{
				{
					0,													// VkDeviceSize					bufferOffset
					0,													// deUint32						bufferRowLength
					0,													// deUint32						bufferImageHeight
					{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },				// VkImageSubresourceLayers		imageSubresource
					{ 0, 0, 0 },										// VkOffset3D					imageOffset
					{ m_densityMapSize.x(), m_densityMapSize.y(), 1u }	// VkExtent3D					imageExtent
				}
			};

			vk::copyBufferToImage
			(
				vk,
				vkDevice,
				m_context.getUniversalQueue(),
				queueFamilyIndex,
				*stagingBuffer,
				stagingBufferSize,
				copyRegions,
				DE_NULL,
				VK_IMAGE_ASPECT_COLOR_BIT,
				1,
				1,
				*m_densityMapImage,
				VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT,
				VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT
			);
		}
#endif

		//create image view for fragment density map
		deUint32 densityMapImageViewCreateFlags = m_testParams.dynamicDensityMap ? (deUint32)VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT : 0u;
		const VkImageViewCreateInfo densityMapImageViewParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,							// VkStructureType			sType;
			DE_NULL,															// const void*				pNext;
			(VkImageViewCreateFlags)densityMapImageViewCreateFlags,				// VkImageViewCreateFlags	flags;
			*m_densityMapImage,													// VkImage					image;
			VK_IMAGE_VIEW_TYPE_2D,												// VkImageViewType			viewType;
			m_testParams.densityMapFormat,										// VkFormat					format;
			componentMappingRGBA,												// VkChannelMapping			channels;
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }						// VkImageSubresourceRange	subresourceRange;
		};

		m_densityMapImageView = createImageView(vk, vkDevice, &densityMapImageViewParams);
	}

	// Create subsampled color image
	{
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	deUint32 colorImageCreateFlags = m_testParams.nonSubsampledImages ? 0u : (deUint32)VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT;
#else
	deUint32 colorImageCreateFlags = 0u;
#endif
		const VkImageCreateInfo	colorImageParams
		{
			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,								// VkStructureType			sType;
			DE_NULL,															// const void*				pNext;
			(VkImageCreateFlags)colorImageCreateFlags,							// VkImageCreateFlags		flags;
			VK_IMAGE_TYPE_2D,													// VkImageType				imageType;
			VK_FORMAT_R8G8B8A8_UNORM,											// VkFormat					format;
			{ m_renderSize.x(), m_renderSize.y(), 1u },							// VkExtent3D				extent;
			1u,																	// deUint32					mipLevels;
			1u,																	// deUint32					arrayLayers;
			VK_SAMPLE_COUNT_1_BIT,												// VkSampleCountFlagBits	samples;
			VK_IMAGE_TILING_OPTIMAL,											// VkImageTiling			tiling;
			VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,	// VkImageUsageFlags		usage;
			VK_SHARING_MODE_EXCLUSIVE,											// VkSharingMode			sharingMode;
			1u,																	// deUint32					queueFamilyIndexCount;
			&queueFamilyIndex,													// const deUint32*			pQueueFamilyIndices;
			VK_IMAGE_LAYOUT_UNDEFINED											// VkImageLayout			initialLayout;
		};

		m_colorImage			= createImage(vk, vkDevice, &colorImageParams);

		// Allocate and bind color image memory
		m_colorImageAlloc		= memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any);
		VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset()));

		// create image view for subsampled image
		const VkImageViewCreateInfo colorImageViewParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,			// VkStructureType			sType;
			DE_NULL,											// const void*				pNext;
			0u,													// VkImageViewCreateFlags	flags;
			*m_colorImage,										// VkImage					image;
			VK_IMAGE_VIEW_TYPE_2D,								// VkImageViewType			viewType;
			VK_FORMAT_R8G8B8A8_UNORM,							// VkFormat					format;
			componentMappingRGBA,								// VkChannelMapping			channels;
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }		// VkImageSubresourceRange	subresourceRange;
		};

		m_colorImageView = createImageView(vk, vkDevice, &colorImageViewParams);
	}

	// Create output image ( data from subsampled color image will be copied into it using sampler with VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT )
	{
		const VkImageCreateInfo	outputImageParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,									// VkStructureType			sType;
			DE_NULL,																// const void*				pNext;
			0u,																		// VkImageCreateFlags		flags;
			VK_IMAGE_TYPE_2D,														// VkImageType				imageType;
			VK_FORMAT_R8G8B8A8_UNORM,												// VkFormat					format;
			{ m_renderSize.x(), m_renderSize.y(), 1u },								// VkExtent3D				extent;
			1u,																		// deUint32					mipLevels;
			1u,																		// deUint32					arrayLayers;
			VK_SAMPLE_COUNT_1_BIT,													// VkSampleCountFlagBits	samples;
			VK_IMAGE_TILING_OPTIMAL,												// VkImageTiling			tiling;
			VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,	// VkImageUsageFlags		usage;
			VK_SHARING_MODE_EXCLUSIVE,												// VkSharingMode			sharingMode;
			1u,																		// deUint32					queueFamilyIndexCount;
			&queueFamilyIndex,														// const deUint32*			pQueueFamilyIndices;
			VK_IMAGE_LAYOUT_UNDEFINED												// VkImageLayout			initialLayout;
		};

		m_outputImage = createImage(vk, vkDevice, &outputImageParams);

		// Allocate and bind input image memory
		m_outputImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_outputImage), MemoryRequirement::Any);
		VK_CHECK(vk.bindImageMemory(vkDevice, *m_outputImage, m_outputImageAlloc->getMemory(), m_outputImageAlloc->getOffset()));

		// create image view for output image
		const VkImageViewCreateInfo outputImageViewParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
			DE_NULL,										// const void*				pNext;
			0u,												// VkImageViewCreateFlags	flags;
			*m_outputImage,									// VkImage					image;
			VK_IMAGE_VIEW_TYPE_2D,							// VkImageViewType			viewType;
			VK_FORMAT_R8G8B8A8_UNORM,						// VkFormat					format;
			componentMappingRGBA,							// VkChannelMapping			channels;
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }	// VkImageSubresourceRange	subresourceRange;
		};

		m_outputImageView = createImageView(vk, vkDevice, &outputImageViewParams);
	}

	// create a sampler that is able to read from subsampled image
	{
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
		deUint32 samplerCreateFlags = m_testParams.nonSubsampledImages ? 0u : (deUint32)VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT;
#else
		deUint32 samplerCreateFlags = 0u;
#endif
		const struct VkSamplerCreateInfo		samplerInfo
		{
			VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,			// sType
			DE_NULL,										// pNext
			(VkSamplerCreateFlags)samplerCreateFlags,		// flags
			VK_FILTER_NEAREST,								// magFilter
			VK_FILTER_NEAREST,								// minFilter
			VK_SAMPLER_MIPMAP_MODE_NEAREST,					// mipmapMode
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,			// addressModeU
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,			// addressModeV
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,			// addressModeW
			0.0f,											// mipLodBias
			VK_FALSE,										// anisotropyEnable
			1.0f,											// maxAnisotropy
			DE_FALSE,										// compareEnable
			VK_COMPARE_OP_ALWAYS,							// compareOp
			0.0f,											// minLod
			0.0f,											// maxLod
			VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,		// borderColor
			VK_FALSE,										// unnormalizedCoords
		};
		m_colorSampler = createSampler(vk, vkDevice, &samplerInfo);
	}

	// Create render passes
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	if ( testParams.dynamicDensityMap )
#endif
		m_renderPassProduceDynamicDensityMap	= createRenderPassProduceDynamicDensityMap<AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(vk, vkDevice, testParams);
	m_renderPassProduceSubsampledImage		= createRenderPassProduceSubsampledImage<AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(vk, vkDevice, testParams);
	m_renderPassOutputSubsampledImage		= createRenderPassOutputSubsampledImage<AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(vk, vkDevice, testParams);

	// Create framebuffers
#if  !DRY_RUN_WITHOUT_FDM_EXTENSION
	if ( testParams.dynamicDensityMap )
#endif
		m_framebufferProduceDynamicDensityMap = createFrameBuffer(vk, vkDevice, *m_renderPassProduceDynamicDensityMap, m_densityMapSize, { *m_densityMapImageView });
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	m_framebufferProduceSubsampledImage = createFrameBuffer(vk, vkDevice, *m_renderPassProduceSubsampledImage, m_renderSize, { *m_colorImageView, *m_densityMapImageView });
#else
	m_framebufferProduceSubsampledImage = createFrameBuffer(vk, vkDevice, *m_renderPassProduceSubsampledImage, m_renderSize, { *m_colorImageView });
#endif
	m_framebufferOutputSubsampledImage	= createFrameBuffer( vk, vkDevice, *m_renderPassOutputSubsampledImage, m_renderSize, { *m_outputImageView } );

	// Create pipeline layout for first two render passes that do not use any descriptors
	{
		const VkPipelineLayoutCreateInfo		pipelineLayoutParams		=
		{
			VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,	// VkStructureType				sType;
			DE_NULL,										// const void*					pNext;
			0u,												// VkPipelineLayoutCreateFlags	flags;
			0u,												// deUint32						setLayoutCount;
			DE_NULL,										// const VkDescriptorSetLayout*	pSetLayouts;
			0u,												// deUint32						pushConstantRangeCount;
			DE_NULL											// const VkPushConstantRange*	pPushConstantRanges;
		};

		m_pipelineLayoutProduceSubsampledImage = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
	}

	// Create pipeline layout for last render pass ( output subsampled image )
	{
		std::vector<VkDescriptorSetLayoutBinding>	descriptorSetLayoutBindings =
		{
			{
				0,											// deUint32				binding;
				VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,	// VkDescriptorType		descriptorType;
				1,											// deUint32				descriptorCount;
				VK_SHADER_STAGE_FRAGMENT_BIT,				// VkShaderStageFlags	stageFlags;
				&(m_colorSampler.get())						// const VkSampler*		pImmutableSamplers;
			},
		};

		const VkDescriptorSetLayoutCreateInfo		descriptorSetLayoutParams	=
		{
			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,		// VkStructureType						sType
			DE_NULL,													// const void*							pNext
			0u,															// VkDescriptorSetLayoutCreateFlags		flags
			static_cast<deUint32>(descriptorSetLayoutBindings.size()),	// deUint32								bindingCount
			descriptorSetLayoutBindings.data()							// const VkDescriptorSetLayoutBinding*	pBindings
		};
		m_descriptorSetLayoutOutputSubsampledImage = createDescriptorSetLayout(vk, vkDevice, &descriptorSetLayoutParams);

		const VkPipelineLayoutCreateInfo		pipelineLayoutParams		=
		{
			VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,		// VkStructureType				sType;
			DE_NULL,											// const void*					pNext;
			0u,													// VkPipelineLayoutCreateFlags	flags;
			1u,													// deUint32						setLayoutCount;
			&m_descriptorSetLayoutOutputSubsampledImage.get(),	// const VkDescriptorSetLayout*	pSetLayouts;
			0u,													// deUint32						pushConstantRangeCount;
			DE_NULL												// const VkPushConstantRange*	pPushConstantRanges;
		};
		m_pipelineLayoutOutputSubsampledImage = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
	}

	// Update descriptor set
	{
		{
			std::vector<VkDescriptorPoolSize> poolSizes =
			{
				{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u }
			};

			const VkDescriptorPoolCreateInfo	descriptorPoolCreateInfo =
			{
				VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,		// VkStructureType				sType
				DE_NULL,											// const void*					pNext
				VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,	// VkDescriptorPoolCreateFlags	flags
				1u,													// deUint32						maxSets
				static_cast<deUint32>(poolSizes.size()),			// deUint32						poolSizeCount
				poolSizes.data()									// const VkDescriptorPoolSize*	pPoolSizes
			};
			m_descriptorPoolOutputSubsampledImage = createDescriptorPool(vk, vkDevice, &descriptorPoolCreateInfo);
		}

		{
			const VkDescriptorSetAllocateInfo	descriptorSetAllocateInfo =
			{
				VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,		// VkStructureType				sType
				DE_NULL,											// const void*					pNext
				*m_descriptorPoolOutputSubsampledImage,				// VkDescriptorPool				descriptorPool
				1u,													// deUint32						descriptorSetCount
				&m_descriptorSetLayoutOutputSubsampledImage.get(),	// const VkDescriptorSetLayout*	pSetLayouts
			};
			m_descriptorSetOutputSubsampledImage = allocateDescriptorSet(vk, vkDevice, &descriptorSetAllocateInfo);

			const VkDescriptorImageInfo			inputImageInfo =
			{
				DE_NULL,											// VkSampleri		sampler;
				*m_colorImageView,									// VkImageView		imageView;
				VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL			// VkImageLayout	imageLayout;
			};

			std::vector<VkWriteDescriptorSet>	descriptorWrite =
			{
				{
					VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,			// VkStructureType					sType;
					DE_NULL,										// const void*						pNext;
					*m_descriptorSetOutputSubsampledImage,			// VkDescriptorSet					dstSet;
					0u,												// deUint32							dstBinding;
					0u,												// deUint32							dstArrayElement;
					1u,												// deUint32							descriptorCount;
					VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,		// VkDescriptorType					descriptorType;
					&inputImageInfo,								// const VkDescriptorImageInfo*		pImageInfo;
					DE_NULL,										// const VkDescriptorBufferInfo*	pBufferInfo;
					DE_NULL											// const VkBufferView*				pTexelBufferView;
				}
			};
			vk.updateDescriptorSets(vkDevice, static_cast<deUint32>(descriptorWrite.size()), descriptorWrite.data(), 0u, DE_NULL);
		}
	}

	m_vertexCommonShaderModule						= createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("densitymap_vert"), 0);
	m_fragmentShaderModuleProduceSubsampledImage	= createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("densitymap_frag_produce"), 0);
	m_fragmentShaderModuleOutputSubsampledImage		= createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("densitymap_frag_output"), 0);

	// Create pipelines
	{
		const VkVertexInputBindingDescription		vertexInputBindingDescription		=
		{
			0u,																// deUint32					binding;
			sizeof(Vertex4RGBA),											// deUint32					strideInBytes;
			VK_VERTEX_INPUT_RATE_VERTEX										// VkVertexInputStepRate	inputRate;
		};

		std::vector<VkVertexInputAttributeDescription>	vertexInputAttributeDescriptions	=
		{
			{ 0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, 0u },
			{ 1u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, (deUint32)(sizeof(float) * 4) }
		};

		const VkPipelineVertexInputStateCreateInfo	vertexInputStateParams				=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// VkStructureType							sType;
			DE_NULL,														// const void*								pNext;
			0u,																// VkPipelineVertexInputStateCreateFlags	flags;
			1u,																// deUint32									vertexBindingDescriptionCount;
			&vertexInputBindingDescription,									// const VkVertexInputBindingDescription*	pVertexBindingDescriptions;
			static_cast<deUint32>(vertexInputAttributeDescriptions.size()),	// deUint32									vertexAttributeDescriptionCount;
			vertexInputAttributeDescriptions.data()							// const VkVertexInputAttributeDescription*	pVertexAttributeDescriptions;
		};

		const std::vector<VkViewport>				viewportsDDM						{ makeViewport(m_densityMapSize) };
		const std::vector<VkRect2D>					scissorsDDM							{ makeRect2D(m_densityMapSize) };
		const std::vector<VkViewport>				viewports							{ makeViewport(m_renderSize) };
		const std::vector<VkRect2D>					scissors							{ makeRect2D(m_renderSize) };

#if !DRY_RUN_WITHOUT_FDM_EXTENSION
		if (testParams.dynamicDensityMap)
#endif
			m_graphicsPipelineProduceDynamicDensityMap = makeGraphicsPipeline(vk,							// const DeviceInterface&						vk
															vkDevice,										// const VkDevice								device
															*m_pipelineLayoutProduceSubsampledImage,		// const VkPipelineLayout						pipelineLayout
															*m_vertexCommonShaderModule,					// const VkShaderModule							vertexShaderModule
															DE_NULL,										// const VkShaderModule							tessellationControlModule
															DE_NULL,										// const VkShaderModule							tessellationEvalModule
															DE_NULL,										// const VkShaderModule							geometryShaderModule
															*m_fragmentShaderModuleProduceSubsampledImage,	// const VkShaderModule							fragmentShaderModule
															*m_renderPassProduceDynamicDensityMap,			// const VkRenderPass							renderPass
															viewportsDDM,									// const std::vector<VkViewport>&				viewports
															scissorsDDM,									// const std::vector<VkRect2D>&					scissors
															VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,			// const VkPrimitiveTopology					topology
															0u,												// const deUint32								subpass
															0u,												// const deUint32								patchControlPoints
															&vertexInputStateParams);						// const VkPipelineVertexInputStateCreateInfo*	vertexInputStateCreateInfo

		m_graphicsPipelineProduceSubsampledImage = makeGraphicsPipeline(vk,									// const DeviceInterface&						vk
															vkDevice,										// const VkDevice								device
															*m_pipelineLayoutProduceSubsampledImage,		// const VkPipelineLayout						pipelineLayout
															*m_vertexCommonShaderModule,					// const VkShaderModule							vertexShaderModule
															DE_NULL,										// const VkShaderModule							tessellationControlModule
															DE_NULL,										// const VkShaderModule							tessellationEvalModule
															DE_NULL,										// const VkShaderModule							geometryShaderModule
															*m_fragmentShaderModuleProduceSubsampledImage,	// const VkShaderModule							fragmentShaderModule
															*m_renderPassProduceSubsampledImage,			// const VkRenderPass							renderPass
															viewports,										// const std::vector<VkViewport>&				viewports
															scissors,										// const std::vector<VkRect2D>&					scissors
															VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,			// const VkPrimitiveTopology					topology
															0u,												// const deUint32								subpass
															0u,												// const deUint32								patchControlPoints
															&vertexInputStateParams);						// const VkPipelineVertexInputStateCreateInfo*	vertexInputStateCreateInfo

		m_graphicsPipelineOutputSubsampledImage = makeGraphicsPipeline(vk,									// const DeviceInterface&						vk
															vkDevice,										// const VkDevice								device
															*m_pipelineLayoutOutputSubsampledImage,			// const VkPipelineLayout						pipelineLayout
															*m_vertexCommonShaderModule,					// const VkShaderModule							vertexShaderModule
															DE_NULL,										// const VkShaderModule							tessellationControlModule
															DE_NULL,										// const VkShaderModule							tessellationEvalModule
															DE_NULL,										// const VkShaderModule							geometryShaderModule
															*m_fragmentShaderModuleOutputSubsampledImage,	// const VkShaderModule							fragmentShaderModule
															*m_renderPassOutputSubsampledImage,				// const VkRenderPass							renderPass
															viewports,										// const std::vector<VkViewport>&				viewports
															scissors,										// const std::vector<VkRect2D>&					scissors
															VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,			// const VkPrimitiveTopology					topology
															0u,												// const deUint32								subpass
															0u,												// const deUint32								patchControlPoints
															&vertexInputStateParams);						// const VkPipelineVertexInputStateCreateInfo*	vertexInputStateCreateInfo
	}

	// Create vertex buffers
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	if (testParams.dynamicDensityMap)
#endif
		createVertexBuffer(vk, vkDevice, queueFamilyIndex, memAlloc, m_verticesDDM, m_vertexBufferDDM, m_vertexBufferAllocDDM);
	createVertexBuffer(vk, vkDevice, queueFamilyIndex, memAlloc, m_vertices, m_vertexBuffer, m_vertexBufferAlloc);

	// Create command pool and command buffer
	m_cmdPool	= createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
	m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	const typename				RenderpassSubpass2::SubpassBeginInfo	subpassBeginInfo(DE_NULL, VK_SUBPASS_CONTENTS_INLINE);
	const typename				RenderpassSubpass2::SubpassEndInfo		subpassEndInfo(DE_NULL);
	const						VkDeviceSize							vertexBufferOffset = 0;
	std::vector<VkClearValue>	attachmentClearValuesDDM				= { makeClearValueColorF32(1.0f, 1.0f, 1.0f, 1.0f) };
	std::vector<VkClearValue>	attachmentClearValues					= { makeClearValueColorF32(0.0f, 0.0f, 0.0f, 1.0f) };

	beginCommandBuffer(vk, *m_cmdBuffer, 0u);

	// first render pass - render dynamic density map
#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	if ( testParams.dynamicDensityMap )
#endif
	{
		const VkRenderPassBeginInfo renderPassBeginInfoProduceDynamicDensityMap =
		{
			VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,				// VkStructureType		sType;
			DE_NULL,												// const void*			pNext;
			*m_renderPassProduceDynamicDensityMap,					// VkRenderPass			renderPass;
			*m_framebufferProduceDynamicDensityMap,					// VkFramebuffer		framebuffer;
			makeRect2D(m_densityMapSize),							// VkRect2D				renderArea;
			static_cast<deUint32>(attachmentClearValuesDDM.size()),	// uint32_t				clearValueCount;
			attachmentClearValuesDDM.data()							// const VkClearValue*	pClearValues;
		};
		RenderpassSubpass2::cmdBeginRenderPass(vk, *m_cmdBuffer, &renderPassBeginInfoProduceDynamicDensityMap, &subpassBeginInfo);
		vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelineProduceDynamicDensityMap);
		vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBufferDDM.get(), &vertexBufferOffset);
		vk.cmdDraw(*m_cmdBuffer, (deUint32)m_verticesDDM.size(), 1, 0, 0);
		RenderpassSubpass2::cmdEndRenderPass(vk, *m_cmdBuffer, &subpassEndInfo);
	}

	// render subsampled image
	const VkRenderPassBeginInfo renderPassBeginInfoProduceSubsampledImage =
	{
		VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,				// VkStructureType		sType;
		DE_NULL,												// const void*			pNext;
		*m_renderPassProduceSubsampledImage,					// VkRenderPass			renderPass;
		*m_framebufferProduceSubsampledImage,					// VkFramebuffer		framebuffer;
		makeRect2D(m_renderSize),								// VkRect2D				renderArea;
		static_cast<deUint32>(attachmentClearValues.size()),	// uint32_t				clearValueCount;
		attachmentClearValues.data()							// const VkClearValue*	pClearValues;
	};
	RenderpassSubpass2::cmdBeginRenderPass(vk, *m_cmdBuffer, &renderPassBeginInfoProduceSubsampledImage, &subpassBeginInfo);
	vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelineProduceSubsampledImage);
	vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset);
	vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1, 0, 0);
	RenderpassSubpass2::cmdEndRenderPass(vk, *m_cmdBuffer, &subpassEndInfo);

	// copy subsampled image to ordinary image using sampler that is able to read from subsampled images( subsampled image cannot be copied using vkCmdCopyImageToBuffer )
	const VkRenderPassBeginInfo renderPassBeginInfoOutputSubsampledImage =
	{
		VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,				// VkStructureType		sType;
		DE_NULL,												// const void*			pNext;
		*m_renderPassOutputSubsampledImage,						// VkRenderPass			renderPass;
		*m_framebufferOutputSubsampledImage,					// VkFramebuffer		framebuffer;
		makeRect2D(m_renderSize),								// VkRect2D				renderArea;
		static_cast<deUint32>(attachmentClearValues.size()),	// uint32_t				clearValueCount;
		attachmentClearValues.data()							// const VkClearValue*	pClearValues;
	};
	RenderpassSubpass2::cmdBeginRenderPass(vk, *m_cmdBuffer, &renderPassBeginInfoOutputSubsampledImage, &subpassBeginInfo);
	vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelineOutputSubsampledImage);
	vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayoutOutputSubsampledImage, 0, 1, &m_descriptorSetOutputSubsampledImage.get(), 0, DE_NULL);
	vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1, 0, 0);
	RenderpassSubpass2::cmdEndRenderPass(vk, *m_cmdBuffer, &subpassEndInfo);

	endCommandBuffer(vk, *m_cmdBuffer);
}

tcu::TestStatus FragmentDensityMapTestInstance::iterate (void)
{
	const DeviceInterface&		vk			= m_context.getDeviceInterface();
	const VkDevice				vkDevice	= m_context.getDevice();
	const VkQueue				queue		= m_context.getUniversalQueue();

	submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());

	return verifyImage();
}

struct Vec4Sorter
{
	bool operator()(const tcu::Vec4& lhs, const tcu::Vec4& rhs) const
	{
		if (lhs.x() != rhs.x())
			return lhs.x() < rhs.x();
		if (lhs.y() != rhs.y())
			return lhs.y() < rhs.y();
		if (lhs.z() != rhs.z())
			return lhs.z() < rhs.z();
		return lhs.w() < rhs.w();
	}
};

tcu::TestStatus FragmentDensityMapTestInstance::verifyImage (void)
{
	const DeviceInterface&				vk						= m_context.getDeviceInterface();
	const VkDevice						vkDevice				= m_context.getDevice();
	const VkQueue						queue					= m_context.getUniversalQueue();
	const deUint32						queueFamilyIndex		= m_context.getUniversalQueueFamilyIndex();
	SimpleAllocator						memAlloc				(vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
	de::UniquePtr<tcu::TextureLevel>	outputImage				(pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, memAlloc, *m_outputImage, VK_FORMAT_R8G8B8A8_UNORM, m_renderSize).release());
	const tcu::ConstPixelBufferAccess&	outputAccess			= outputImage->getAccess();
	tcu::TestLog&						log						= m_context.getTestContext().getLog();

	// log images
	log << tcu::TestLog::ImageSet("Result", "Result images")
		<< tcu::TestLog::Image("Rendered", "Rendered output image", outputAccess)
		<< tcu::TestLog::EndImageSet;

#if !DRY_RUN_WITHOUT_FDM_EXTENSION
	deUint32 estimatedColorCount = m_testParams.fragmentArea.x() * m_testParams.fragmentArea.y();
#else
	deUint32 estimatedColorCount = 1u;
#endif
	tcu::Vec2 density{
		1.0f / static_cast<float>(m_testParams.fragmentArea.x()),
		1.0f / static_cast<float>(m_testParams.fragmentArea.y())
	};
	float densityMult = density.x() * density.y();

	// create histogram of all image colors, check the value of inverted FragSizeEXT
	std::map<tcu::Vec4, deUint32, Vec4Sorter> colorCount;
	for (int y = 0; y < outputAccess.getHeight(); y++)
	{
		for (int x = 0; x < outputAccess.getWidth(); x++)
		{
			tcu::Vec4 outputColor	= outputAccess.getPixel(x, y);
			float densityClamped	= outputColor.z() * outputColor.w();
			if ((densityClamped + 0.01) < densityMult)
				return tcu::TestStatus::fail("Wrong value of FragSizeEXT variable");
			auto it = colorCount.find(outputColor);
			if (it == end(colorCount))
				it = colorCount.insert({ outputColor, 0u }).first;
			it->second++;
		}
	}

	// check if color count is the same as estimated one
	for (const auto& color : colorCount)
	{
		if (color.second > estimatedColorCount)
			return tcu::TestStatus::fail("Wrong color count");
	}

	return tcu::TestStatus::pass("Pass");
}

} // anonymous

tcu::TestCaseGroup* createFragmentDensityMapTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup>		fdmTests		(new tcu::TestCaseGroup(testCtx, "fragment_density_map", "VK_EXT_fragment_density_map extension tests"));

	std::vector<tcu::UVec2> fragmentArea
	{
		{ 1, 2 },
		{ 2, 1 },
		{ 2, 2 }
	};

	for (const auto& area : fragmentArea)
	{
		std::stringstream str;
		str << "_" << area.x() << "_" << area.y();
		fdmTests->addChild(new FragmentDensityMapTest(testCtx, std::string("static_subsampled")		+ str.str(), "", TestParams(false, false, area)));
		fdmTests->addChild(new FragmentDensityMapTest(testCtx, std::string("dynamic_subsampled")	+ str.str(), "", TestParams(true, false, area)));
		fdmTests->addChild(new FragmentDensityMapTest(testCtx, std::string("static_nonsubsampled")	+ str.str(), "", TestParams(false, true, area)));
		fdmTests->addChild(new FragmentDensityMapTest(testCtx, std::string("dynamic_nonsubsampled")	+ str.str(), "", TestParams(true, true, area)));
	}

	return fdmTests.release();
}

} // renderpass

} // vkt