/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2022 The Khronos Group Inc.
 * Copyright (c) 2022 Google LLC.
 *
 * 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
 *//*--------------------------------------------------------------------*/

#include "vktPipelineImage2DViewOf3DTests.hpp"
#include "vkPipelineConstructionUtil.hpp"
#include "vktTestCase.hpp"
#include "vkImageUtil.hpp"
#include "vkPrograms.hpp"
#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkBarrierUtil.hpp"
#include "tcuTexture.hpp"
#include "tcuPlatform.hpp"
#include "tcuImageCompare.hpp"
#include "deMemory.h"

#include <sstream>
#include <vector>

namespace vkt
{
namespace pipeline
{

using namespace vk;
using de::MovePtr;

namespace
{
enum ImageAccessType {
	StorageImage = 0,
	Sampler,
	CombinedImageSampler
};

enum TestType {
	Compute,
	Fragment
};

struct TestParameters {
	tcu::IVec3					imageSize;
	uint32_t					mipLevel;
	int32_t						layerNdx;
	ImageAccessType				imageType;
	TestType					testType;
	VkFormat					imageFormat;
	PipelineConstructionType	pipelineConstructionType;
};

inline int32_t computeMipLevelDimension (int32_t baseLevelDimension, uint32_t mipLevel)
{
	return de::max(baseLevelDimension >> mipLevel, 1);
}

tcu::IVec3 computeMipLevelSize (tcu::IVec3 baseLevelSize, uint32_t mipLevel)
{
	int32_t width = computeMipLevelDimension(baseLevelSize.x(), mipLevel);
	int32_t height = computeMipLevelDimension(baseLevelSize.y(), mipLevel);
	int32_t depth = computeMipLevelDimension(baseLevelSize.z(), mipLevel);
	return tcu::IVec3(width, height, depth);
}

void copyImageLayerToBuffer (const DeviceInterface&		vk,
							 VkCommandBuffer			cmdBuffer,
							 VkImage					image,
							 VkBuffer					buffer,
							 tcu::IVec2					size,
							 VkAccessFlags				srcAccessMask,
							 VkImageLayout				oldLayout,
							 deUint32					layerToCopy,
							 uint32_t					mipLevel)
{
	const VkImageSubresourceRange	subresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 1u, 0, 1u);
	const VkImageMemoryBarrier		imageBarrier		=
	{
		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType
		DE_NULL,									// const void*				pNext
		srcAccessMask,								// VkAccessFlags			srcAccessMask
		VK_ACCESS_TRANSFER_READ_BIT,				// VkAccessFlags			dstAccessMask
		oldLayout,									// VkImageLayout			oldLayout
		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// VkImageLayout			newLayout
		VK_QUEUE_FAMILY_IGNORED,					// deUint32					srcQueueFamilyIndex
		VK_QUEUE_FAMILY_IGNORED,					// deUint32					destQueueFamilyIndex
		image,										// VkImage					image
		subresourceRange							// VkImageSubresourceRange	subresourceRange
	};

	vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
						  0u, DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);

	const VkImageSubresourceLayers	subresource			=
	{
		subresourceRange.aspectMask,	// VkImageAspectFlags	aspectMask
		mipLevel,						// deUint32				mipLevel
		0u,								// deUint32				baseArrayLayer
		1u,								// deUint32				layerCount
	};

	const VkBufferImageCopy			region				=
	{
		0ull,										// VkDeviceSize					bufferOffset
		0u,											// deUint32						bufferRowLength
		0u,											// deUint32						bufferImageHeight
		subresource,								// VkImageSubresourceLayers		imageSubresource
		makeOffset3D(0, 0, (int)layerToCopy),		// VkOffset3D					imageOffset
		makeExtent3D(size.x(), size.y(), 1u)		// VkExtent3D					imageExtent
	};

	vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, &region);

	const VkBufferMemoryBarrier		bufferBarrier		=
	{
		VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,	// VkStructureType	sType
		DE_NULL,									// const void*		pNext
		VK_ACCESS_TRANSFER_WRITE_BIT,				// VkAccessFlags	srcAccessMask
		VK_ACCESS_HOST_READ_BIT,					// VkAccessFlags	dstAccessMask
		VK_QUEUE_FAMILY_IGNORED,					// deUint32			srcQueueFamilyIndex
		VK_QUEUE_FAMILY_IGNORED,					// deUint32			dstQueueFamilyIndex
		buffer,										// VkBuffer			buffer
		0ull,										// VkDeviceSize		offset
		VK_WHOLE_SIZE								// VkDeviceSize		size
	};

	vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
						  0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
}

// Draws a chess pattern to the given 'layer' (z-dimension) of the 'image'. Other layers will be cleared to white.
void fillImage (const tcu::PixelBufferAccess& image, const int layer)
{
	const tcu::Vec4 clearColor = tcu::Vec4(1); // White clear color.
	for (int z = 0; z < image.getSize().z(); ++z)
	for (int y = 0; y < image.getSize().y(); ++y)
	for (int x = 0; x < image.getSize().x(); ++x)
	{
		if (z == layer)
		{
			const float c = (float)((x + y) & 1);
			const tcu::Vec4 color = tcu::Vec4(c, c, c, 1.0f);
			image.setPixel(color, x, y, z);
		}
		else
		{
			image.setPixel(clearColor, x, y, z);
		}
	}
}


class Image2DView3DImageInstance : public vkt::TestInstance
{
public:
								Image2DView3DImageInstance		(Context&				context,
																 const TestParameters	testParameters)
								: vkt::TestInstance(context),
								  m_testParameters(testParameters)
								{}

	tcu::TestStatus				iterate							(void);
private:
	void						runComputePipeline				(const VkDescriptorSet&			descriptorSet,
																 const VkDescriptorSetLayout	descriptorSetLayout,
																 tcu::IVec3&					testMipLevelSize,
																 VkCommandBuffer				cmdBuffer,
																 VkImage						image,
																 VkBuffer						outputBuffer);

	void						runGraphicsPipeline				(const VkDescriptorSet&			descriptorSet,
																 const VkDescriptorSetLayout	descriptorSetLayout,
																 tcu::IVec3&					testMipLevelSize,
																 VkCommandBuffer				cmdBuffer,
																 VkImage						image,
																 VkBuffer						outputBuffer);
	const TestParameters		m_testParameters;
};

void Image2DView3DImageInstance::runComputePipeline (const VkDescriptorSet&			descriptorSet,
													 const VkDescriptorSetLayout	descriptorSetLayout,
													 tcu::IVec3&					testMipLevelSize,
													 VkCommandBuffer				cmdBuffer,
													 VkImage						image,
													 VkBuffer						outputBuffer)
{
	const DeviceInterface&			vk					= m_context.getDeviceInterface();
	const VkDevice					device				= m_context.getDevice();
	const VkQueue					queue				= m_context.getUniversalQueue();
	const bool						useSampler			= m_testParameters.imageType != StorageImage;

	const Unique<VkShaderModule>	shaderModule		(createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0u));
	const Unique<VkPipelineLayout>	pipelineLayout		(makePipelineLayout(vk, device, descriptorSetLayout));
	const Unique<VkPipeline>		pipeline			(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));

	vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
	vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
	vk.cmdDispatch(cmdBuffer, testMipLevelSize.x(), testMipLevelSize.y(), 1u);

	// Copy the result image to a buffer.
	copyImageLayerToBuffer(vk, cmdBuffer, image, outputBuffer, testMipLevelSize.xy(), VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL, useSampler ? 0u : m_testParameters.layerNdx, useSampler ? 0u : m_testParameters.mipLevel);

	endCommandBuffer(vk, cmdBuffer);

	// Wait for completion.
	submitCommandsAndWait(vk, device, queue, cmdBuffer);
}

void Image2DView3DImageInstance::runGraphicsPipeline (const VkDescriptorSet&		descriptorSet,
													  const VkDescriptorSetLayout	descriptorSetLayout,
													  tcu::IVec3&					testMipLevelSize,
													  VkCommandBuffer				cmdBuffer,
													  VkImage						image,
													  VkBuffer						outputBuffer)
{
	const DeviceInterface&							vk								= m_context.getDeviceInterface();
	const VkDevice									device							= m_context.getDevice();
	const VkQueue									queue							= m_context.getUniversalQueue();
	const bool										useSampler						= m_testParameters.imageType != StorageImage;

	const Unique<VkShaderModule>					vertShader						(createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0u));
	const Unique<VkShaderModule>					fragShader						(createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0u));
	const Unique<VkPipelineLayout>					pipelineLayout					(makePipelineLayout(vk, device, descriptorSetLayout));
	const Move<VkRenderPass>						renderPass						= makeRenderPass(vk, device);
	const std::vector<VkViewport>					viewport						= {makeViewport	(m_testParameters.imageSize.x(), m_testParameters.imageSize.y())};
	const std::vector<VkRect2D>						scissor							= {makeRect2D	(m_testParameters.imageSize.x(), m_testParameters.imageSize.y())};

	const VkPipelineInputAssemblyStateCreateInfo	inputAssemblyStateCreateInfo	=
	{
		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// VkStructureType							sType
		DE_NULL,														// const void*								pNext
		0u,																// VkPipelineInputAssemblyStateCreateFlags	flags
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,								// VkPrimitiveTopology						topology
		VK_FALSE														// VkBool32									primitiveRestartEnable
	};

	const VkVertexInputBindingDescription			vertexInputBindingDescription		=
		{
			0u,								// deUint32				binding
			sizeof(tcu::Vec4),				// deUint32				stride
			VK_VERTEX_INPUT_RATE_VERTEX,	// VkVertexInputRate	inputRate
		};

	const VkVertexInputAttributeDescription			vertexInputAttributeDescription		=
		{
			0u,								// deUint32		location
			0u,								// deUint32		binding
			VK_FORMAT_R32G32B32A32_SFLOAT,	// VkFormat		format
			0u								// deUint32		offset
		};

	const VkPipelineVertexInputStateCreateInfo		vertexInputStateCreateInfoDefault	=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,	// VkStructureType								sType
			DE_NULL,													// const void*									pNext
			(VkPipelineVertexInputStateCreateFlags)0,					// VkPipelineVertexInputStateCreateFlags		flags
			1u,															// deUint32										vertexBindingDescriptionCount
			&vertexInputBindingDescription,								// const VkVertexInputBindingDescription*		pVertexBindingDescriptions
			1u,															// deUint32										vertexAttributeDescriptionCount
			&vertexInputAttributeDescription							// const VkVertexInputAttributeDescription*		pVertexAttributeDescriptions
		};

	vk::GraphicsPipelineWrapper		graphicsPipeline	(vk, device, m_testParameters.pipelineConstructionType, 0u);
	graphicsPipeline.setMonolithicPipelineLayout(*pipelineLayout)
			.setDefaultDepthStencilState()
			.setDefaultRasterizationState()
			.setDefaultMultisampleState()
			.setupVertexInputState(&vertexInputStateCreateInfoDefault, &inputAssemblyStateCreateInfo)
			.setupPreRasterizationShaderState(viewport,
											  scissor,
											  *pipelineLayout,
											  *renderPass,
											  0u,
											  *vertShader)
			.setupFragmentShaderState(*pipelineLayout, *renderPass, 0u, *fragShader)
			.setupFragmentOutputState(*renderPass, 0u)
			.buildPipeline();

	const Move<VkFramebuffer> framebuffer = makeFramebuffer(vk, device, *renderPass, 0u, DE_NULL, testMipLevelSize.x(), testMipLevelSize.y());

	// Create vertex buffer and fill it with full screen quad.
	const std::vector<tcu::Vec4> vertexData = {
			{-1, -1, 1, 1},
			{ 1, -1, 1, 1},
			{ 1,  1, 1, 1},
			{-1,  1, 1, 1},
	};
	size_t vertexBufferSize = sizeof(tcu::Vec4) * vertexData.size();
	BufferWithMemory vertexBuffer(
			vk,
			device,
			m_context.getDefaultAllocator(),
			makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT),
			MemoryRequirement::HostVisible);
	deMemcpy(vertexBuffer.getAllocation().getHostPtr(), vertexData.data(), vertexBufferSize);
	flushAlloc(vk, device, vertexBuffer.getAllocation());

	VkDeviceSize vertexBufferOffset = 0;
	vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &*vertexBuffer, &vertexBufferOffset);

	vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline.getPipeline());
	vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);

	beginRenderPass(vk, cmdBuffer, *renderPass, *framebuffer, makeRect2D(testMipLevelSize.xy()));
	vk.cmdDraw(cmdBuffer, 4, 1, 0, 0);
	endRenderPass(vk, cmdBuffer);

	// Copy the result image to a buffer.
	copyImageLayerToBuffer(vk, cmdBuffer, image, outputBuffer, testMipLevelSize.xy(), VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL, useSampler ? 0u : m_testParameters.layerNdx, useSampler ? 0u : m_testParameters.mipLevel);

	endCommandBuffer(vk, cmdBuffer);

	// Wait for completion.
	submitCommandsAndWait(vk, device, queue, cmdBuffer);
}

tcu::TestStatus Image2DView3DImageInstance::iterate (void)
{
	const DeviceInterface&				vk					= m_context.getDeviceInterface();
	const VkDevice						device				= m_context.getDevice();
	const VkQueue						queue				= m_context.getUniversalQueue();
	const deUint32						queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
	Allocator&							allocator			= m_context.getDefaultAllocator();
	tcu::IVec3							imageSize			= m_testParameters.imageSize;
	const bool							useSampler			= m_testParameters.imageType != StorageImage;
	const tcu::TextureFormat			textureFormat		= mapVkFormat(m_testParameters.imageFormat);
	const uint32_t						mipLevelCount		= 3;

	tcu::IVec3							testMipLevelSize	= computeMipLevelSize(m_testParameters.imageSize, m_testParameters.mipLevel);
	uint32_t							bufferSize			= testMipLevelSize.x() * testMipLevelSize.y() * testMipLevelSize.z() * textureFormat.getPixelSize();
	const BufferWithMemory				outputBuffer		(vk, device, allocator, makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);

	// Input image is used with sampler cases only.
	de::MovePtr<BufferWithMemory>		inputImageBuffer;

	// Upload the test image data for sampler cases.
	if (useSampler)
	{
		// Initialize the input image's mip level and fill the target layer with a chess pattern, others will be white.
		tcu::TextureLevel			inputImageMipLevel	(textureFormat, testMipLevelSize.x(), testMipLevelSize.y(), testMipLevelSize.z());
		fillImage(inputImageMipLevel.getAccess(), m_testParameters.layerNdx);

		// Create a buffer to upload the image.
		const VkBufferCreateInfo	bufferCreateInfo	= makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
		inputImageBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));

		// Upload target mip level to the input buffer.
		deMemcpy(inputImageBuffer->getAllocation().getHostPtr(), inputImageMipLevel.getAccess().getDataPtr(), bufferSize);
		flushAlloc(vk, device, inputImageBuffer->getAllocation());
	}

	// Create the test image: sampled image or storage image, depending on the test type.
	const VkImageUsageFlags				usage				= VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
																VK_IMAGE_USAGE_TRANSFER_DST_BIT |
																(useSampler ? VK_IMAGE_USAGE_SAMPLED_BIT : VK_IMAGE_USAGE_STORAGE_BIT);
	const VkImageCreateInfo				imageCreateInfo		=
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,						// VkStructureType			sType
		DE_NULL,													// const void*				pNext
		VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,					// VkImageCreateFlags		flags
		VK_IMAGE_TYPE_3D,											// VkImageType				imageType
		m_testParameters.imageFormat,								// VkFormat					format
		makeExtent3D(imageSize.x(), imageSize.y(), imageSize.z()),	// VkExtent3D				extent
		(uint32_t)mipLevelCount,									// uint32_t					mipLevels
		1u,															// uint32_t					arrayLayers
		VK_SAMPLE_COUNT_1_BIT,										// VkSampleCountFlagBits	samples
		VK_IMAGE_TILING_OPTIMAL,									// VkImageTiling			tiling
		usage,														// VkImageUsageFlags		usage
		VK_SHARING_MODE_EXCLUSIVE,									// VkSharingMode			sharingMode
		0u,															// uint32_t					queueFamilyIndexCount
		DE_NULL,													// const uint32_t*			pQueueFamilyIndices
		VK_IMAGE_LAYOUT_UNDEFINED,									// VkImageLayout			initialLayout
	};
	ImageWithMemory						testImage			(vk, device, allocator, imageCreateInfo, MemoryRequirement::Any);

	// Make an image view covering one of the mip levels.
	const VkImageSubresourceRange		subresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, m_testParameters.mipLevel, 1u, m_testParameters.layerNdx, 1u);
	const Unique<VkImageView>			imageView			(makeImageView(vk, device, *testImage, VK_IMAGE_VIEW_TYPE_2D, m_testParameters.imageFormat, subresourceRange));

	// resultImage is used in sampler / combined image sampler tests to verify the sampled image.
	MovePtr<ImageWithMemory>			resultImage;
	Move<VkImageView>					resultImageView;
	Move<VkSampler>						sampler;
	if (useSampler)
	{
		const VkImageCreateInfo			resultImageCreateInfo		=
		{
			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,							// VkStructureType			sType
			DE_NULL,														// const void*				pNext
			0U,																// VkImageCreateFlags		flags
			VK_IMAGE_TYPE_2D,												// VkImageType				imageType
			m_testParameters.imageFormat,									// VkFormat					format
			makeExtent3D(testMipLevelSize.x(), testMipLevelSize.y(), 1),	// VkExtent3D				extent
			1u,																// deUint32					mipLevels
			1u,																// deUint32					arrayLayers
			VK_SAMPLE_COUNT_1_BIT,											// VkSampleCountFlagBits	samples
			VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling			tiling
			VK_IMAGE_USAGE_STORAGE_BIT |
				VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
				VK_IMAGE_USAGE_TRANSFER_DST_BIT,							// VkImageUsageFlags		usage
			VK_SHARING_MODE_EXCLUSIVE,										// VkSharingMode			sharingMode
			0u,																// deUint32					queueFamilyIndexCount
			DE_NULL,														// const deUint32*			pQueueFamilyIndices
			VK_IMAGE_LAYOUT_UNDEFINED,										// VkImageLayout			initialLayout
		};

		resultImage = MovePtr<ImageWithMemory>(new ImageWithMemory(vk, device, allocator, resultImageCreateInfo, MemoryRequirement::Any));
		const VkImageSubresourceRange	resultImgSubresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
		resultImageView = makeImageView(vk, device, **resultImage, VK_IMAGE_VIEW_TYPE_2D, m_testParameters.imageFormat, resultImgSubresourceRange);

		const VkSamplerCreateInfo		samplerCreateInfo			=
		{
			VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,		// VkStructureType			sType
			DE_NULL,									// const void*				pNext
			(VkSamplerCreateFlags)0,					// VkSamplerCreateFlags		flags
			VK_FILTER_NEAREST,							// VkFilter					magFilter
			VK_FILTER_NEAREST,							// VkFilter					minFilter
			VK_SAMPLER_MIPMAP_MODE_NEAREST,				// VkSamplerMipmapMode		mipmapMode
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeU
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeV
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeW
			0.0f,										// float					mipLodBias
			VK_FALSE,									// VkBool32					anisotropyEnable
			1.0f,										// float					maxAnisotropy
			VK_FALSE,									// VkBool32					compareEnable
			VK_COMPARE_OP_ALWAYS,						// VkCompareOp				compareOp
			0.0f,										// float					minLod
			1.0f,										// float					maxLod
			VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,	// VkBorderColor			borderColor
			VK_FALSE,									// VkBool32					unnormalizedCoordinates
		};
		sampler = createSampler(vk, device, &samplerCreateInfo);
	}


	// Create the descriptor set.
	DescriptorSetLayoutBuilder			descriptorSetLayoutBuilder;
	DescriptorPoolBuilder				descriptorPoolBuilder;

	VkShaderStageFlags					shaderStage					= m_testParameters.testType == Compute ? VK_SHADER_STAGE_COMPUTE_BIT : VK_SHADER_STAGE_FRAGMENT_BIT;
	VkPipelineStageFlags				pipelineStage				= m_testParameters.testType == Compute ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
	switch (m_testParameters.imageType)
	{
	case StorageImage:
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, shaderStage);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
		break;
	case Sampler:
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, shaderStage);
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLER, shaderStage);
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, shaderStage);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_SAMPLER);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
		break;
	case CombinedImageSampler:
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, shaderStage);
		descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, shaderStage);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
		descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
		break;
	default:
		TCU_THROW(InternalError, "Unimplemented testImage type.");
	}

	if (useSampler)
	{
		// Clear the result image.
		clearColorImage(vk, device, queue, m_context.getUniversalQueueFamilyIndex(), **resultImage, tcu::Vec4(0,0,0,1), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, pipelineStage, 0u, 1u);
	}
	else
	{
		// Clear the test image.
		clearColorImage(vk, device, queue, m_context.getUniversalQueueFamilyIndex(), testImage.get(), tcu::Vec4(0,0,0,1), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, pipelineStage, 0u, 1u, 0u, mipLevelCount);
	}

	// Prepare the command buffer.
	const Unique<VkCommandPool>			cmdPool						(makeCommandPool(vk, device, queueFamilyIndex));
	const Unique<VkCommandBuffer>		cmdBuffer					(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));

	// Start recording commands.
	beginCommandBuffer(vk, *cmdBuffer);

	if (useSampler)
	{
		// Copy the input image to the target mip level.
		std::vector<VkBufferImageCopy> copies;
		copies.push_back(makeBufferImageCopy(makeExtent3D(testMipLevelSize), makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, m_testParameters.mipLevel, 0, 1)));
		copyBufferToImage(vk, *cmdBuffer, **inputImageBuffer, bufferSize, copies, VK_IMAGE_ASPECT_COLOR_BIT, mipLevelCount, 1u, *testImage, VK_IMAGE_LAYOUT_GENERAL, pipelineStage);
	}

	const Move<VkDescriptorSetLayout>	descriptorSetLayout			(descriptorSetLayoutBuilder.build(vk, device));
	const Move<VkDescriptorPool>		descriptorPool				(descriptorPoolBuilder.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
	const Unique<VkDescriptorSet>		descriptorSet				(makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
	const VkDescriptorImageInfo			testImageDescriptorInfo		= makeDescriptorImageInfo(*sampler, *imageView, VK_IMAGE_LAYOUT_GENERAL);

	// Write descriptor update.
	{
		DescriptorSetUpdateBuilder descriptorSetUpdateBuilder;
		uint32_t bindingIdx = 0;

		switch (m_testParameters.imageType)
		{
		case StorageImage:
			descriptorSetUpdateBuilder.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &testImageDescriptorInfo);
			break;
		case Sampler:
			descriptorSetUpdateBuilder.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingIdx++), VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &testImageDescriptorInfo);
			descriptorSetUpdateBuilder.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingIdx++), VK_DESCRIPTOR_TYPE_SAMPLER, &testImageDescriptorInfo);
			break;
		case CombinedImageSampler:
			descriptorSetUpdateBuilder.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingIdx++), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &testImageDescriptorInfo);
			break;
		}

		if (useSampler)
		{
			const VkDescriptorImageInfo resultImageDescriptorInfo = makeDescriptorImageInfo(DE_NULL, *resultImageView, VK_IMAGE_LAYOUT_GENERAL);
			descriptorSetUpdateBuilder.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingIdx), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &resultImageDescriptorInfo);
		}

		descriptorSetUpdateBuilder.update(vk, device);
	}

	if (m_testParameters.testType == Compute)
		runComputePipeline(*descriptorSet, *descriptorSetLayout, testMipLevelSize, *cmdBuffer, useSampler ? **resultImage : *testImage, *outputBuffer);
	else
		runGraphicsPipeline(*descriptorSet, *descriptorSetLayout, testMipLevelSize, *cmdBuffer, useSampler ? **resultImage : *testImage, *outputBuffer);

	// Validate the results.
	{
		// Create a reference image.
		// The reference image has always a depth of 1, because it will be compared to the 2D result image (sampler cases) or to a single layer of a 3D image.
		tcu::TextureLevel			referenceImage			(textureFormat, testMipLevelSize.x(), testMipLevelSize.y(), 1u);
		fillImage(referenceImage.getAccess(), 0u);

		const Allocation&			outputBufferAllocation	= outputBuffer.getAllocation();
		invalidateAlloc(vk, device, outputBufferAllocation);

		const deUint32*				bufferPtr				= static_cast<deUint32*>(outputBufferAllocation.getHostPtr());
		tcu::ConstPixelBufferAccess	pixelBufferAccess		(mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM), testMipLevelSize.x(), testMipLevelSize.y(), 1u, bufferPtr);

		if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Result", "Result comparison", referenceImage, pixelBufferAccess, tcu::Vec4(0.01f), tcu::COMPARE_LOG_ON_ERROR))
			return tcu::TestStatus::fail("Pixel comparison failed.");

	}

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

class ComputeImage2DView3DImageTest : public vkt::TestCase
{
public:
								ComputeImage2DView3DImageTest	(tcu::TestContext&				testContext,
																 const char*					name,
																 const char*					description,
																 const TestParameters&			testParameters)
																 : vkt::TestCase (testContext, name, description),
																 m_testParameters (testParameters) {}
	virtual						~ComputeImage2DView3DImageTest			(void) {}

	virtual void				initPrograms					(SourceCollections&				sourceCollections) const;
	virtual void				checkSupport					(Context&						context) const;
	virtual TestInstance*		createInstance					(Context&						context) const;
private:
	const TestParameters		m_testParameters;
};


void ComputeImage2DView3DImageTest::checkSupport (Context& context) const
{
	DE_ASSERT(m_testParameters.pipelineConstructionType == PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC);

	if (!context.isDeviceFunctionalitySupported("VK_EXT_image_2d_view_of_3d"))
		TCU_THROW(NotSupportedError, "VK_EXT_image_2d_view_of_3d functionality not supported.");

	if (!context.getImage2DViewOf3DFeaturesEXT().image2DViewOf3D)
		TCU_THROW(NotSupportedError, "image2DViewOf3D not supported.");

	if (m_testParameters.imageType != StorageImage && !context.getImage2DViewOf3DFeaturesEXT().sampler2DViewOf3D)
		TCU_THROW(NotSupportedError, "sampler2DViewOf3D not supported.");
}

void ComputeImage2DView3DImageTest::initPrograms (SourceCollections& sourceCollections) const
{
	std::ostringstream src;
	tcu::IVec3 mipLevelSize = computeMipLevelSize(m_testParameters.imageSize, m_testParameters.mipLevel);
	if (m_testParameters.imageType == StorageImage)
	{
		src << "#version 450 core\n"
			<< "layout (local_size_x = 1, local_size_y = 1) in;\n"
			<< "layout (binding = 0, rgba8) writeonly uniform highp image2D storageImage;\n"
			<< "void main (void) {\n"
			<< "    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);\n"
			<< "    float c = float((uv.x + uv.y) & 1);\n"
			<< "    vec4 color = vec4(c, c, c, 1.0);\n"
			<< "    imageStore(storageImage, uv, color);\n"
			<< "}\n";
	}
	else if (m_testParameters.imageType == Sampler)
	{
		src << "#version 450 core\n"
			<< "layout (local_size_x = 1, local_size_y = 1) in;\n"
			<< "layout (set=0, binding = 0) uniform texture2D image;\n"
			<< "layout (set=0, binding = 1) uniform sampler samp;\n"
			<< "layout (rgba8, set=0, binding = 2) writeonly uniform highp image2D verifyImage;\n"
			<< "void main (void) {\n"
			<< "    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);\n"
			<< "    vec2 texCoord = vec2(gl_GlobalInvocationID.xy) / " << mipLevelSize.x() <<".0;\n"
			<< "    vec4 color = texture(sampler2D(image, samp), texCoord);\n"
			<< "    imageStore(verifyImage, uv, color);\n"
			<< "}\n";
	}
	else if (m_testParameters.imageType == CombinedImageSampler)
	{
		src << "#version 450 core\n"
			<< "layout (local_size_x = 1, local_size_y = 1) in;\n"
			<< "layout (binding = 0) uniform sampler2D combinedSampler;\n"
			<< "layout (rgba8, set=0, binding=1) writeonly uniform highp image2D verifyImage;\n"
			<< "void main (void) {\n"
			<< "    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);\n"
			<< "    vec2 texCoord = vec2(gl_GlobalInvocationID.xy) / " << mipLevelSize.x() <<".0;\n"
			<< "    vec4 color = texture(combinedSampler, texCoord);\n"
			<< "    imageStore(verifyImage, uv, color);\n"
			<< "}\n";
	}

	sourceCollections.glslSources.add("comp") << glu::ComputeSource(src.str());
}

TestInstance* ComputeImage2DView3DImageTest::createInstance (Context& context) const
{
	return new Image2DView3DImageInstance(context, m_testParameters);
}

class FragmentImage2DView3DImageTest : public vkt::TestCase
{
public:
								FragmentImage2DView3DImageTest	(tcu::TestContext&				testContext,
																 const char*					name,
																 const char*					description,
																 const TestParameters&			testParameters)
																 : vkt::TestCase (testContext, name, description),
																 m_testParameters (testParameters) {}
	virtual						~FragmentImage2DView3DImageTest	(void) {}

	virtual void				initPrograms					(SourceCollections&				sourceCollections) const;
	virtual void				checkSupport					(Context&						context) const;
	virtual TestInstance*		createInstance					(Context&						context) const;
private:
	const TestParameters		m_testParameters;
};

void FragmentImage2DView3DImageTest::initPrograms (SourceCollections& sourceCollections) const
{
	std::stringstream vertShader;
	vertShader	<< "#version 450 core\n"
				<< "layout(location = 0) in vec4 in_position;\n"
				<< "out gl_PerVertex {\n"
				<< "    vec4  gl_Position;\n"
				<< "    float gl_PointSize;\n"
				<< "};\n"
				<< "void main() {\n"
				<< "    gl_PointSize = 1.0;\n"
				<< "    gl_Position  = in_position;\n"
				<< "}\n";
	sourceCollections.glslSources.add("vert") << glu::VertexSource(vertShader.str());

	tcu::IVec3 mipLevelSize = computeMipLevelSize(m_testParameters.imageSize, m_testParameters.mipLevel);
	std::stringstream fragShader;
	if (m_testParameters.imageType == StorageImage)
	{
		fragShader	<< "#version 450 core\n"
					<< "layout(rgba8, set = 0, binding = 0) uniform image2D storageImage;\n"
					<< "void main()\n"
					<< "{\n"
					<< "    ivec2 uv = ivec2(gl_FragCoord.xy);\n"
					<< "    float c = float((uv.x + uv.y) & 1);\n"
					<< "    vec4 color = vec4(c, c, c, 1.0);\n"
					<< "    imageStore(storageImage, uv, color);\n"
					<< "}\n";
	}

	else if (m_testParameters.imageType == Sampler)
	{
		fragShader	<< "#version 450 core\n"
					<< "layout (set = 0, binding = 0) uniform texture2D image;\n"
					<< "layout (set = 0, binding = 1) uniform sampler samp;\n"
					<< "layout (rgba8, set = 0, binding = 2) uniform image2D verifyImage;\n"
					<< "void main (void) {\n"
					<< "    ivec2 uv = ivec2(gl_FragCoord.xy);\n"
					<< "    vec2 texCoord = gl_FragCoord.xy / " << mipLevelSize.x() <<".0;\n"
					<< "    vec4 color = texture(sampler2D(image, samp), texCoord);\n"
					<< "    imageStore(verifyImage, uv, color);\n"
					<< "}\n";
	}
	else if (m_testParameters.imageType == CombinedImageSampler)
	{
		fragShader	<< "#version 450 core\n"
					<< "layout (set = 0, binding = 0) uniform sampler2D combinedSampler;\n"
					<< "layout (rgba8, set = 0, binding = 1) uniform image2D verifyImage;\n"
					<< "void main (void) {\n"
					<< "    ivec2 uv = ivec2(gl_FragCoord.xy);\n"
					<< "    vec2 texCoord = gl_FragCoord.xy / " << mipLevelSize.x() <<".0;\n"
					<< "    vec4 color = texture(combinedSampler, texCoord);\n"
					<< "    imageStore(verifyImage, uv, color);\n"
					<< "}\n";
	}
	sourceCollections.glslSources.add("frag") << glu::FragmentSource(fragShader.str());
}

void FragmentImage2DView3DImageTest::checkSupport (Context& context) const
{
	checkPipelineLibraryRequirements(context.getInstanceInterface(), context.getPhysicalDevice(), m_testParameters.pipelineConstructionType);

	if (!context.isDeviceFunctionalitySupported("VK_EXT_image_2d_view_of_3d"))
		TCU_THROW(NotSupportedError, "VK_EXT_image_2d_view_of_3d functionality not supported.");

	if (!context.getImage2DViewOf3DFeaturesEXT().image2DViewOf3D)
		TCU_THROW(NotSupportedError, "image2DViewOf3D not supported.");

	if (m_testParameters.imageType != StorageImage && !context.getImage2DViewOf3DFeaturesEXT().sampler2DViewOf3D)
		TCU_THROW(NotSupportedError, "texture2DViewOf3D not supported.");

	if (!context.getDeviceFeatures().fragmentStoresAndAtomics)
		TCU_THROW(NotSupportedError, "fragmentStoresAndAtomics not supported");
}

TestInstance* FragmentImage2DView3DImageTest::createInstance (Context& context) const
{
	return new Image2DView3DImageInstance(context, m_testParameters);
}

} // anonymous

tcu::TestCaseGroup* createImage2DViewOf3DTests (tcu::TestContext& testCtx, PipelineConstructionType pipelineConstructionType)
{
	de::MovePtr<tcu::TestCaseGroup> imageTests			(new tcu::TestCaseGroup(testCtx, "image_2d_view_3d_image", "2D view 3D image tests"));
	de::MovePtr<tcu::TestCaseGroup>	computeGroup		(new tcu::TestCaseGroup(testCtx, "compute", "Compute shader tests."));
	de::MovePtr<tcu::TestCaseGroup>	fragmentGroup		(new tcu::TestCaseGroup(testCtx, "fragment", "Fragment shader tests."));

	const struct {
		const ImageAccessType	imageType;
		const std::string		name;
	} imageAccessTypes [] {
		{ StorageImage,			"storage" },
		{ Sampler,				"sampler" },
		{ CombinedImageSampler,	"combined_image_sampler" }
	};

	const int32_t imageDimension = 64;
	for (const auto& imageAccessType : imageAccessTypes)
	{
		de::MovePtr<tcu::TestCaseGroup>	computeSubGroup		(new tcu::TestCaseGroup(testCtx, imageAccessType.name.c_str(), "Fragment shader tests."));
		de::MovePtr<tcu::TestCaseGroup>	fragmentSubGroup	(new tcu::TestCaseGroup(testCtx, imageAccessType.name.c_str(), "Fragment shader tests."));
		for (uint32_t mipLevel = 0; mipLevel < 3; mipLevel += 2)
		{
			// Test the first and the last layer of the mip level.
			std::vector<int32_t> layers = { 0, computeMipLevelDimension(imageDimension, mipLevel) -1 };
			for (const auto& layer : layers)
			{
				TestParameters testParameters {
						tcu::IVec3(imageDimension),	// IVec3						imageSize
						mipLevel,					// uint32_t						mipLevel
						layer,						// int32_t						layerNdx
						imageAccessType.imageType,	// ImageAccessType				imageType
						Fragment,					// TestType						testType
						VK_FORMAT_R8G8B8A8_UNORM,	// VkFormat						imageFormat
						pipelineConstructionType	// PipelineConstructionType		pipelineConstructionType
					};
				std::string testName = "mip" + std::to_string(mipLevel) +  "_layer" + std::to_string(layer);
				fragmentSubGroup->addChild(new FragmentImage2DView3DImageTest(testCtx, testName.c_str(), "description", testParameters));

				if (pipelineConstructionType == PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
				{
					testParameters.testType = Compute;
					computeSubGroup->addChild(new ComputeImage2DView3DImageTest(testCtx, testName.c_str(), "description", testParameters));
				}
			}
		}
		computeGroup->addChild(computeSubGroup.release());
		fragmentGroup->addChild(fragmentSubGroup.release());
	}

	imageTests->addChild(computeGroup.release());
	imageTests->addChild(fragmentGroup.release());
	return imageTests.release();
}

} // pipeline
} // vkt