/*------------------------------------------------------------------------
 * ------------------------
 *
 * Copyright (c) 2021 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 Sample cube faces that has been rendered to tests
 *//*--------------------------------------------------------------------*/

#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"

#include "tcuVectorType.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTexture.hpp"

#include "vkDefs.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkPrograms.hpp"
#include "vkMemUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBarrierUtil.hpp"

#include "vktTestCaseUtil.hpp"
#include "tcuTestLog.hpp"

#include <string>

using namespace vk;

namespace vkt
{
namespace image
{
namespace
{

using tcu::TestLog;
using tcu::IVec2;
using tcu::IVec3;
using tcu::IVec4;
using tcu::Vec2;
using tcu::Vec4;
using std::vector;
using de::MovePtr;
using tcu::TextureLevel;
using tcu::PixelBufferAccess;
using tcu::ConstPixelBufferAccess;

inline VkImageCreateInfo makeImageCreateInfo (const IVec3& size, const VkFormat& format, bool cubemap)
{
	const VkImageUsageFlags		usage		= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT
											  | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
											  | VK_IMAGE_USAGE_SAMPLED_BIT;
	const VkImageCreateFlags flags = cubemap ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0;
	const VkImageCreateInfo	imageParams	=
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					//  VkStructureType         sType;
		DE_NULL,												//  const void*             pNext;
		flags,													//  VkImageCreateFlags      flags;
		VK_IMAGE_TYPE_2D,										//  VkImageType             imageType;
		format,													//  VkFormat                format;
		makeExtent3D(size.x(), size.y(), 1u),					//  VkExtent3D              extent;
		1u,														//  deUint32                mipLevels;
		(cubemap ? 6u : 1u),									//  deUint32                arrayLayers;
		VK_SAMPLE_COUNT_1_BIT,									//  VkSampleCountFlagBits   samples;
		VK_IMAGE_TILING_OPTIMAL,								//  VkImageTiling           tiling;
		usage,													//  VkImageUsageFlags       usage;
		VK_SHARING_MODE_EXCLUSIVE,								//  VkSharingMode           sharingMode;
		0u,														//  deUint32                queueFamilyIndexCount;
		DE_NULL,												//  const deUint32*         pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED,								//  VkImageLayout           initialLayout;
	};

	return imageParams;
}

Move<VkBuffer> makeVertexBuffer (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
{
	const VkBufferCreateInfo vertexBufferParams =
	{
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,		// VkStructureType      sType;
		DE_NULL,									// const void*          pNext;
		0u,											// VkBufferCreateFlags  flags;
		1024u,										// VkDeviceSize     size;
		VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,			// VkBufferUsageFlags   usage;
		VK_SHARING_MODE_EXCLUSIVE,					// VkSharingMode        sharingMode;
		1u,											// deUint32             queueFamilyIndexCount;
		&queueFamilyIndex							// const deUint32*      pQueueFamilyIndices;
	};

	Move<VkBuffer>			vertexBuffer		= createBuffer(vk, device, &vertexBufferParams);;
	return vertexBuffer;
}

class SampleDrawnCubeFaceTestInstance : public TestInstance
{
public:
					SampleDrawnCubeFaceTestInstance	(Context&			context,
													 const IVec2&		size,
													 const VkFormat		format);
	tcu::TestStatus	iterate							(void);

private:
	const tcu::IVec2&	m_size;
	const VkFormat		m_format;
};

SampleDrawnCubeFaceTestInstance::SampleDrawnCubeFaceTestInstance (Context& context, const IVec2& size, const VkFormat format)
	: TestInstance	(context)
	, m_size		(size)
	, m_format		(format)
{
}

template<typename T>
inline size_t sizeInBytes (const vector<T>& vec)
{
	return vec.size() * sizeof(vec[0]);
}

Move<VkSampler> makeSampler (const DeviceInterface& vk, const VkDevice& device)
{
	const VkSamplerCreateInfo samplerParams =
	{
		VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,		// VkStructureType          sType;
		DE_NULL,									// const void*              pNext;
		(VkSamplerCreateFlags)0,					// VkSamplerCreateFlags     flags;
		VK_FILTER_LINEAR,							// VkFilter                 magFilter;
		VK_FILTER_LINEAR,							// VkFilter                 minFilter;
		VK_SAMPLER_MIPMAP_MODE_NEAREST,				// VkSamplerMipmapMode      mipmapMode;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,				// VkSamplerAddressMode     addressModeU;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,				// VkSamplerAddressMode     addressModeV;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,				// 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;
		0.0f,										// float                    maxLod;
		VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,	// VkBorderColor            borderColor;
		VK_FALSE,									// VkBool32                 unnormalizedCoordinates;
	};

	return createSampler(vk, device, &samplerParams);
}

// Draw a quad covering the whole framebuffer
vector<Vec4> genFullQuadVertices (void)
{
	vector<Vec4> vertices;
	vertices.push_back(Vec4(-1.0f, -1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4( 1.0f, -1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4(-1.0f,  1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4(1.0f,  -1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4(1.0f, 1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4(-1.0f,  1.0f, 0.0f, 1.0f));

	return vertices;
}

struct Vertex
{
	Vertex(Vec4 vertices_, Vec2 uv_) : vertices(vertices_), uv(uv_) {}
	Vec4 vertices;
	Vec2 uv;

	static VkVertexInputBindingDescription					getBindingDescription		(void);
	static vector<VkVertexInputAttributeDescription>		getAttributeDescriptions	(void);
};

VkVertexInputBindingDescription Vertex::getBindingDescription (void)
{
	static const VkVertexInputBindingDescription desc =
	{
		0u,										// deUint32             binding;
		static_cast<deUint32>(sizeof(Vertex)),	// deUint32             stride;
		VK_VERTEX_INPUT_RATE_VERTEX,			// VkVertexInputRate    inputRate;
	};

	return desc;
}

vector<VkVertexInputAttributeDescription> Vertex::getAttributeDescriptions (void)
{
	static const vector<VkVertexInputAttributeDescription> desc =
	{
		{
			0u,													// deUint32    location;
			0u,													// deUint32    binding;
			vk::VK_FORMAT_R32G32B32A32_SFLOAT,					// VkFormat    format;
			static_cast<deUint32>(offsetof(Vertex, vertices)),	// deUint32    offset;
		},
		{
			1u,													// deUint32    location;
			0u,													// deUint32    binding;
			vk::VK_FORMAT_R32G32_SFLOAT,						// VkFormat    format;
			static_cast<deUint32>(offsetof(Vertex, uv)),		// deUint32    offset;
		},
	};

	return desc;
}

vector<Vertex> genTextureCoordinates (void)
{
	vector<Vertex> vertices;
	vertices.push_back(Vertex(Vec4(-1.0f, -1.0f, 0.0f, 1.0f), Vec2(0.0f, 0.0f)));
	vertices.push_back(Vertex(Vec4( 1.0f, -1.0f, 0.0f, 1.0f), Vec2(1.0f, 0.0f)));
	vertices.push_back(Vertex(Vec4(-1.0f,  1.0f, 0.0f, 1.0f), Vec2(0.0f, 1.0f)));
	vertices.push_back(Vertex(Vec4(1.0f,  -1.0f, 0.0f, 1.0f), Vec2(1.0f, 0.0f)));
	vertices.push_back(Vertex(Vec4(1.0f, 1.0f, 0.0f, 1.0f), Vec2(1.0f, 1.0f)));
	vertices.push_back(Vertex(Vec4(-1.0f,  1.0f, 0.0f, 1.0f), Vec2(0.0f, 1.0f)));

	return vertices;
}

tcu::TestStatus SampleDrawnCubeFaceTestInstance::iterate (void)
{
	DE_ASSERT(m_format == VK_FORMAT_R8G8B8A8_UNORM);

	const DeviceInterface&			vk						= m_context.getDeviceInterface();
	const VkDevice					device					= m_context.getDevice();
	Allocator&						allocator				= m_context.getDefaultAllocator();
	const VkQueue					queue					= m_context.getUniversalQueue();
	const deUint32					queueFamilyIndex		= m_context.getUniversalQueueFamilyIndex();
	const VkDeviceSize				bufferSize				= 1024;

	const deUint32					layerStart				= 0;
	const deUint32					layerCount				= 6;
	const deUint32					levelCount				= 1;

	const IVec3						imageSize				= {m_size.x(), m_size.y(), (deInt32)layerCount};
	const VkExtent2D				renderSize				= {deUint32(m_size.x()), deUint32(m_size.y())};
	const VkRect2D					renderArea				= makeRect2D(makeExtent3D(m_size.x(), m_size.y(), 1u));
	const vector<VkRect2D>			scissors				(1u, renderArea);
	const vector<VkViewport>		viewports				(1u, makeViewport(makeExtent3D(m_size.x(), m_size.y(), 1u)));

	const vector<Vec4>				vertices				= genFullQuadVertices();
	Move<VkBuffer>					vertexBuffer			= makeVertexBuffer(vk, device, queueFamilyIndex);
	MovePtr<Allocation>				vertexBufferAlloc		= bindBuffer(vk, device, allocator, *vertexBuffer, MemoryRequirement::HostVisible);
	const VkDeviceSize				vertexBufferOffset		= 0ull;

	deMemcpy(vertexBufferAlloc->getHostPtr(), &vertices[0], sizeInBytes(vertices));
	flushAlloc(vk, device, *vertexBufferAlloc);

	// Create a cubemap image.
	const VkImageCreateInfo			cubemapCreateInfo		= makeImageCreateInfo(imageSize, m_format, true);
	const VkImageSubresourceRange	cubemapSubresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, layerStart, layerCount);
	const ImageWithMemory			cubemapImage			(vk, device, m_context.getDefaultAllocator(), cubemapCreateInfo, MemoryRequirement::Any);
	Move<VkImageView>				cubemapImageView		= makeImageView(vk, device, *cubemapImage, VK_IMAGE_VIEW_TYPE_CUBE, m_format, cubemapSubresourceRange);

	// Create a sampler for the cubemap and bind it.
	Move<VkImageView>				sampledImageView		= makeImageView(vk, device, *cubemapImage, VK_IMAGE_VIEW_TYPE_CUBE, m_format, cubemapSubresourceRange);
	const Unique<VkSampler>			cubemapSampler			(makeSampler(vk, device));
	const VkDescriptorImageInfo		descriptorImageInfo		= makeDescriptorImageInfo(cubemapSampler.get(), *sampledImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

	const auto						descriptorSetLayout	(DescriptorSetLayoutBuilder()
										.addSingleSamplerBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, &cubemapSampler.get())
										.build(vk, device));

	const Unique<VkDescriptorPool>	descriptorPool			(DescriptorPoolBuilder()
										.addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u)
										.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));

	const Unique<VkDescriptorSet>	descriptorSet			(makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));

	DescriptorSetUpdateBuilder()
			.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u),
						 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfo)
			.update(vk, device);

	// Generate texture coordinates for the sampler.
	vector<Vertex>					uvCoordinates			= genTextureCoordinates();
	Move<VkBuffer>					uvBuffer				= makeVertexBuffer(vk, device, queueFamilyIndex);
	de::MovePtr<Allocation>			uvBufferAlloc			= bindBuffer(vk, device, allocator, *uvBuffer, MemoryRequirement::HostVisible);
	const VkDeviceSize				uvBufferOffset			= 0ull;

	deMemcpy(uvBufferAlloc->getHostPtr(), &uvCoordinates[0], uvCoordinates.size() * sizeof (Vertex));
	flushAlloc(vk, device, *uvBufferAlloc);

	// Sampled values will be written to this image.
	const VkImageSubresourceRange	targetSubresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, layerStart, 1);
	const VkImageCreateInfo			targetImageCreateInfo	= makeImageCreateInfo(imageSize, m_format, false);
	const ImageWithMemory			targetImage				(vk, device, m_context.getDefaultAllocator(), targetImageCreateInfo, MemoryRequirement::Any);
	Move<VkImageView>				targetImageView			= makeImageView(vk, device, *targetImage, VK_IMAGE_VIEW_TYPE_2D, m_format, targetSubresourceRange);

	// We use a push constant to hold count for how many times the shader has written to the cubemap.
	const VkPushConstantRange		pushConstantRange		= {
			VK_SHADER_STAGE_FRAGMENT_BIT,		// VkShaderStageFlags    stageFlags;
			0u,									// uint32_t              offset;
			(deUint32)sizeof(deUint32),			// uint32_t              size;
	};

	const Move<VkCommandPool>		cmdPool					= createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
	const Move<VkCommandBuffer>		cmdBuffer				= allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	// Create two graphic pipelines. One for writing to the cubemap and the other for sampling it.
	Move<VkRenderPass>				renderPass1				= makeRenderPass (vk, device, m_format, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD,
																			  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
																			  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, DE_NULL);

	Move<VkFramebuffer>				framebuffer1			= makeFramebuffer(vk, device, *renderPass1, cubemapImageView.get(), renderSize.width, renderSize.height);

	const Move<VkShaderModule>		vertexModule1			= createShaderModule (vk, device, m_context.getBinaryCollection().get("vert1"), 0u);
	const Move<VkShaderModule>		fragmentModule1			= createShaderModule (vk, device, m_context.getBinaryCollection().get("frag1"), 0u);

	const Move<VkPipelineLayout>	pipelineLayout1			= makePipelineLayout (vk, device, 0, DE_NULL, 1, &pushConstantRange);
	const Move<VkPipeline>			graphicsPipeline1		= makeGraphicsPipeline(vk, device, pipelineLayout1.get(), vertexModule1.get(),
																				   DE_NULL, DE_NULL, DE_NULL, fragmentModule1.get(), renderPass1.get(),
																				   viewports, scissors, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0u, 0u,
																				   DE_NULL);

	Move<VkRenderPass>				renderPass2				= makeRenderPass(vk, device, m_format, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);

	Move<VkFramebuffer>				framebuffer2			= makeFramebuffer(vk, device, *renderPass2, targetImageView.get(), renderSize.width, renderSize.height);

	Move<VkShaderModule>			vertexModule2			= createShaderModule(vk, device, m_context.getBinaryCollection().get("vert2"), 0u);
	Move<VkShaderModule>			fragmentModule2			= createShaderModule(vk, device, m_context.getBinaryCollection().get("frag2"), 0u);

	const Move<VkPipelineLayout>	pipelineLayout2			= makePipelineLayout(vk, device, *descriptorSetLayout);

	const auto						vtxBindingDescription	= Vertex::getBindingDescription();
	const auto						vtxAttrDescriptions		= Vertex::getAttributeDescriptions();

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

	const Move<VkPipeline>			graphicsPipeline2		= makeGraphicsPipeline(vk, device, pipelineLayout2.get(), vertexModule2.get(),
																				   DE_NULL, DE_NULL, DE_NULL, fragmentModule2.get(),
																				   renderPass2.get(), viewports, scissors,
																				   VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0u, 0u, &vertexInputInfo);

	// The values sampled in the second pipeline will be copied to this buffer.
	const VkBufferCreateInfo		resultBufferCreateInfo	= makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	Move<VkBuffer>					resultBuffer			= createBuffer(vk, device, &resultBufferCreateInfo);
	MovePtr<Allocation>				resultBufferMemory		= allocator.allocate(getBufferMemoryRequirements(vk, device, *resultBuffer), MemoryRequirement::HostVisible);
	MovePtr<TextureLevel>			resultImage				(new TextureLevel(mapVkFormat(m_format), renderSize.width, renderSize.height, 1));

	VK_CHECK(vk.bindBufferMemory(device, *resultBuffer, resultBufferMemory->getMemory(), resultBufferMemory->getOffset()));

	// Clear the cubemap faces and the target image as black.
	const Vec4						clearColor				(0.0f, 0.0f, 0.0f, 1.0f);

	clearColorImage(vk, device, m_context.getUniversalQueue(), m_context.getUniversalQueueFamilyIndex(),
					cubemapImage.get(), clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
					VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, layerCount);

	clearColorImage(vk, device, m_context.getUniversalQueue(), m_context.getUniversalQueueFamilyIndex(),
					targetImage.get(), clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
					VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 1u);

	// Run the shaders twice.
	beginCommandBuffer(vk, *cmdBuffer);

	vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout2, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);

	for (int pass = 0; pass < 2; pass++)
	{
		//  Draw on the first cube map face.
		vk.cmdPushConstants(*cmdBuffer, *pipelineLayout1, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(deInt32), &pass);
		vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline1);
		vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);

		beginRenderPass(vk, *cmdBuffer, *renderPass1, *framebuffer1, makeRect2D(0, 0, imageSize.x(), imageSize.y()), 0, DE_NULL);
		vk.cmdDraw(*cmdBuffer, static_cast<deUint32>(vertices.size()), 1u, 0u, 0u);
		endRenderPass(vk, *cmdBuffer);

		{
			const auto barrier = makeImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
														VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
														cubemapImage.get(), cubemapSubresourceRange);
			vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier);
		}

		// Sample the four faces around the first face.
		vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline2);

		vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &uvBuffer.get(), &uvBufferOffset);

		beginRenderPass(vk, *cmdBuffer, *renderPass2, *framebuffer2, makeRect2D(0, 0, imageSize.x(), imageSize.y()), 0u, DE_NULL);
		vk.cmdDraw(*cmdBuffer, 6u, 1u, 0u, 0u);
		endRenderPass(vk, *cmdBuffer);

		if (pass == 0)
		{
			const auto	barrier		= makeImageMemoryBarrier(0u, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
															 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, cubemapImage.get(), cubemapSubresourceRange);
			vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier);

			const auto	barrier2	= makeImageMemoryBarrier(0u, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
															 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
															 targetImage.get(), targetSubresourceRange);
			vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1u, &barrier2);
		}
	}

	// Read the result buffer data
	copyImageToBuffer(vk, *cmdBuffer, *targetImage, *resultBuffer, IVec2(m_size.x(), m_size.y()), VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);

	endCommandBuffer(vk, *cmdBuffer);
	submitCommandsAndWait(vk, device, queue, *cmdBuffer);

	invalidateAlloc(vk, device, *resultBufferMemory);

	tcu::clear(resultImage->getAccess(), IVec4(0));
	tcu::copy(resultImage->getAccess(), ConstPixelBufferAccess(resultImage.get()->getFormat(),
			  resultImage.get()->getSize(), resultBufferMemory->getHostPtr()));

	bool result = true;

	// The first run writes pure red and the second pure blue hence the value of the red component
	// should be 0.0 and the value in the blue channel > 0.0.
	for (deUint32 y = 0; y < renderSize.height; y++)
	{
		const deUint8* ptr = static_cast<const deUint8 *>(resultImage->getAccess().getPixelPtr(renderSize.width-1, y, 0));
		const IVec4 val = IVec4(ptr[0], ptr[1], ptr[2], ptr[3]);
		if (!(val[0] == 0 && val[1] > 0))
			result = false;
	}

	// Log attachment contents
	m_context.getTestContext().getLog() << tcu::TestLog::ImageSet("Attachment ", "")
	<< tcu::TestLog::Image("Rendered image", "Rendered image", resultImage->getAccess())
	<< tcu::TestLog::EndImageSet;

	if (result)
		return tcu::TestStatus::pass("pass");
	else
		return tcu::TestStatus::fail("fail");
}

class SampleDrawnCubeFaceTest : public TestCase
{
public:
						SampleDrawnCubeFaceTest	(tcu::TestContext&	testCtx,
												const std::string&	name,
												const std::string&	description,
												const tcu::IVec2&	size,
												const VkFormat		format);

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

private:
	const tcu::IVec2	m_size;
	const VkFormat		m_format;
};

SampleDrawnCubeFaceTest::SampleDrawnCubeFaceTest (tcu::TestContext&	testCtx,
												 const std::string&	name,
												 const std::string&	description,
												 const tcu::IVec2&	size,
												 const VkFormat		format)
	: TestCase	(testCtx, name, description)
	, m_size	(size)
	, m_format	(format)
{
}

void SampleDrawnCubeFaceTest::initPrograms (SourceCollections& programCollection) const
{
	std::ostringstream pipeline1VertexSrc;
	pipeline1VertexSrc
		<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
		<< "layout(location = 0) in vec4 a_position;\n"
		<< "void main (void) {\n"
		<< "    gl_Position = a_position;\n"
		<< "}\n";

	std::ostringstream pipeline1FragmentSrc;
	pipeline1FragmentSrc
			<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
			<< "layout(location = 0) out vec4 outColor;\n"
			<< "layout(push_constant) uniform constants {\n"
			<< "     int pass;\n"
			<< "} pc;\n"
			<< "void main() {\n"
			<< "   if (pc.pass == 1) {\n"
			<< "      outColor = vec4(0., 1., 1., 1.);\n"
			<< "    } else {\n"
			<< "      outColor = vec4(1., 0., 1., 1.);\n"
			<< "    }\n"
			<< "}\n";

	std::ostringstream pipeline2VertexSrc;
	pipeline2VertexSrc
		<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
		<< "layout(location = 0) in highp vec4 a_position;\n"
		<< "layout(location = 1) in vec2 inTexCoord;\n"
		<< "layout(location = 1) out vec2 fragTexCoord;\n"
		<< "void main (void) {\n"
		<< "    gl_Position = a_position;\n"
		<< "    fragTexCoord = inTexCoord;\n"
		<< "}\n";

	std::ostringstream pipeline2FragmentSrc;
	pipeline2FragmentSrc
		<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
		<< "layout(location = 0) out vec4 outColor;\n"
		<< "layout(location = 1) in vec2 fragTexCoord;\n"
		<< "layout(binding = 0) uniform samplerCube texSampler;\n"
		<< "void main() {\n"
		<< "     outColor = texture(texSampler, vec3(fragTexCoord.x, 1.0, fragTexCoord.y));\n"
		<< "     outColor += texture(texSampler, vec3(fragTexCoord.x, -1.0, fragTexCoord.y));\n"
		<< "     outColor += texture(texSampler, vec3(fragTexCoord.x, fragTexCoord.y, 1.0));\n"
		<< "     outColor += texture(texSampler, vec3(fragTexCoord.x, fragTexCoord.y, -1.0));\n"
		<< "     outColor /= 4.;\n"
		<< "}\n";

	programCollection.glslSources.add("vert1") << glu::VertexSource(pipeline1VertexSrc.str());
	programCollection.glslSources.add("vert2") << glu::VertexSource(pipeline2VertexSrc.str());
	programCollection.glslSources.add("frag1") << glu::FragmentSource(pipeline1FragmentSrc.str());
	programCollection.glslSources.add("frag2") << glu::FragmentSource(pipeline2FragmentSrc.str());
}

TestInstance* SampleDrawnCubeFaceTest::createInstance (Context& context) const
{
	return new SampleDrawnCubeFaceTestInstance(context, m_size, m_format);
}

} // anonymous ns

tcu::TestCaseGroup* createImageSampleDrawnCubeFaceTests	(tcu::TestContext& testCtx)
{
	const VkFormat		format	= VK_FORMAT_R8G8B8A8_UNORM;
	const tcu::IVec2	size	= tcu::IVec2(8, 8);

	de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "sample_cubemap", "Sample cube map faces that has been rendered to tests"));

	testGroup->addChild(new SampleDrawnCubeFaceTest(testCtx, "write_face_0", "", size, format));

	return testGroup.release();
}

} // image
} // vkt