/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2014 The Android Open Source Project
 * Copyright (c) 2016 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 Tessellation Geometry Interaction - Grid render (limits, scatter)
*//*--------------------------------------------------------------------*/

#include "vktTessellationGeometryGridRenderTests.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktTessellationUtil.hpp"

#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuSurface.hpp"
#include "tcuRGBA.hpp"

#include "vkDefs.hpp"
#include "vkQueryUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"

#include "deUniquePtr.hpp"

#include <string>
#include <vector>

namespace vkt
{
namespace tessellation
{

using namespace vk;

namespace
{

enum Constants
{
	RENDER_SIZE = 256,
};

enum FlagBits
{
	FLAG_TESSELLATION_MAX_SPEC			= 1u << 0,
	FLAG_GEOMETRY_MAX_SPEC				= 1u << 1,
	FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC	= 1u << 2,

	FLAG_GEOMETRY_SCATTER_INSTANCES		= 1u << 3,
	FLAG_GEOMETRY_SCATTER_PRIMITIVES	= 1u << 4,
	FLAG_GEOMETRY_SEPARATE_PRIMITIVES	= 1u << 5, //!< if set, geometry shader outputs separate grid cells and not continuous slices
	FLAG_GEOMETRY_SCATTER_LAYERS		= 1u << 6,
};
typedef deUint32 Flags;

class GridRenderTestCase : public TestCase
{
public:
	void			initPrograms			(vk::SourceCollections& programCollection) const;
	TestInstance*	createInstance			(Context& context) const;

					GridRenderTestCase		(tcu::TestContext& testCtx, const std::string& name, const std::string& description, const Flags flags);

private:
	const Flags		m_flags;
	const int		m_tessGenLevel;
	const int		m_numGeometryInvocations;
	const int		m_numLayers;
	int				m_numGeometryPrimitivesPerInvocation;
};

GridRenderTestCase::GridRenderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const Flags flags)
	: TestCase					(testCtx, name, description)
	, m_flags					(flags)
	, m_tessGenLevel			((m_flags & FLAG_TESSELLATION_MAX_SPEC)			? 64 : 5)
	, m_numGeometryInvocations	((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)	? 32 : 4)
	, m_numLayers				((m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)		? 8  : 1)
{
	DE_ASSERT(((flags & (FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS)) != 0) == ((flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0));

	testCtx.getLog()
		<< tcu::TestLog::Message
		<< "Testing tessellation and geometry shaders that output a large number of primitives.\n"
		<< getDescription()
		<< tcu::TestLog::EndMessage;

	if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
		m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to 2d texture array, numLayers = " << m_numLayers << tcu::TestLog::EndMessage;

	m_testCtx.getLog()
		<< tcu::TestLog::Message
		<< "Tessellation level: " << m_tessGenLevel << ", mode = quad.\n"
		<< "\tEach input patch produces " << (m_tessGenLevel*m_tessGenLevel) << " (" << (m_tessGenLevel*m_tessGenLevel*2) << " triangles)\n"
		<< tcu::TestLog::EndMessage;

	int geometryOutputComponents	  = 0;
	int geometryOutputVertices		  = 0;
	int geometryTotalOutputComponents = 0;

	if (m_flags & FLAG_GEOMETRY_MAX_SPEC)
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Using geometry shader minimum maximum output limits." << tcu::TestLog::EndMessage;

		geometryOutputComponents	  = 64;
		geometryOutputVertices		  = 256;
		geometryTotalOutputComponents = 1024;
	}
	else
	{
		geometryOutputComponents	  = 64;
		geometryOutputVertices		  = 16;
		geometryTotalOutputComponents = 1024;
	}

	if ((m_flags & FLAG_GEOMETRY_MAX_SPEC) || (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC))
	{
		tcu::MessageBuilder msg(&m_testCtx.getLog());

		msg << "Geometry shader, targeting following limits:\n";

		if (m_flags & FLAG_GEOMETRY_MAX_SPEC)
			msg	<< "\tmaxGeometryOutputComponents = "	   << geometryOutputComponents << "\n"
				<< "\tmaxGeometryOutputVertices = "		   << geometryOutputVertices << "\n"
				<< "\tmaxGeometryTotalOutputComponents = " << geometryTotalOutputComponents << "\n";

		if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)
			msg << "\tmaxGeometryShaderInvocations = "	   << m_numGeometryInvocations;

		msg << tcu::TestLog::EndMessage;
	}

	const bool	separatePrimitives				  = (m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0;
	const int	numComponentsPerVertex			  = 8; // vec4 pos, vec4 color
	int			numVerticesPerInvocation		  = 0;
	int			geometryVerticesPerPrimitive	  = 0;
	int			geometryPrimitivesOutPerPrimitive = 0;

	if (separatePrimitives)
	{
		const int	numComponentLimit		 = geometryTotalOutputComponents / (4 * numComponentsPerVertex);
		const int	numOutputLimit			 = geometryOutputVertices / 4;

		m_numGeometryPrimitivesPerInvocation = de::min(numComponentLimit, numOutputLimit);
		numVerticesPerInvocation			 = m_numGeometryPrimitivesPerInvocation * 4;
	}
	else
	{
		// If FLAG_GEOMETRY_SEPARATE_PRIMITIVES is not set, geometry shader fills a rectangle area in slices.
		// Each slice is a triangle strip and is generated by a single shader invocation.
		// One slice with 4 segment ends (nodes) and 3 segments:
		//    .__.__.__.
		//    |\ |\ |\ |
		//    |_\|_\|_\|

		const int	numSliceNodesComponentLimit	= geometryTotalOutputComponents / (2 * numComponentsPerVertex);			// each node 2 vertices
		const int	numSliceNodesOutputLimit	= geometryOutputVertices / 2;											// each node 2 vertices
		const int	numSliceNodes				= de::min(numSliceNodesComponentLimit, numSliceNodesOutputLimit);

		numVerticesPerInvocation				= numSliceNodes * 2;
		m_numGeometryPrimitivesPerInvocation	= (numSliceNodes - 1) * 2;
	}

	geometryVerticesPerPrimitive	  = numVerticesPerInvocation * m_numGeometryInvocations;
	geometryPrimitivesOutPerPrimitive = m_numGeometryPrimitivesPerInvocation * m_numGeometryInvocations;

	m_testCtx.getLog()
		<< tcu::TestLog::Message
		<< "Geometry shader:\n"
		<< "\tTotal output vertex count per invocation: "		  << numVerticesPerInvocation << "\n"
		<< "\tTotal output primitive count per invocation: "	  << m_numGeometryPrimitivesPerInvocation << "\n"
		<< "\tNumber of invocations per primitive: "			  << m_numGeometryInvocations << "\n"
		<< "\tTotal output vertex count per input primitive: "	  << geometryVerticesPerPrimitive << "\n"
		<< "\tTotal output primitive count per input primitive: " << geometryPrimitivesOutPerPrimitive << "\n"
		<< tcu::TestLog::EndMessage;

	m_testCtx.getLog()
		<< tcu::TestLog::Message
		<< "Program:\n"
		<< "\tTotal program output vertices count per input patch: "  << (m_tessGenLevel*m_tessGenLevel*2 * geometryVerticesPerPrimitive) << "\n"
		<< "\tTotal program output primitive count per input patch: " << (m_tessGenLevel*m_tessGenLevel*2 * geometryPrimitivesOutPerPrimitive) << "\n"
		<< tcu::TestLog::EndMessage;
}

void GridRenderTestCase::initPrograms (SourceCollections& programCollection) const
{
	// Vertex shader
	{
		std::ostringstream src;
		src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
			<< "\n"
			<< "void main (void)\n"
			<< "{\n"
			<< "    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
			<< "}\n";

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

	// Fragment shader
	{
		std::ostringstream src;
		src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
			<< "layout(location = 0) flat in highp   vec4 v_color;\n"
			<< "layout(location = 0) out     mediump vec4 fragColor;\n"
			<< "\n"
			<< "void main (void)\n"
			<< "{\n"
			<< "    fragColor = v_color;\n"
			<< "}\n";

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

	// Tessellation control
	{
		std::ostringstream src;
		src <<	glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
				"#extension GL_EXT_tessellation_shader : require\n"
				"layout(vertices = 1) out;\n"
				"\n"
				"void main (void)\n"
				"{\n"
				"    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
				"    gl_TessLevelInner[0] = float(" << m_tessGenLevel << ");\n"
				"    gl_TessLevelInner[1] = float(" << m_tessGenLevel << ");\n"
				"    gl_TessLevelOuter[0] = float(" << m_tessGenLevel << ");\n"
				"    gl_TessLevelOuter[1] = float(" << m_tessGenLevel << ");\n"
				"    gl_TessLevelOuter[2] = float(" << m_tessGenLevel << ");\n"
				"    gl_TessLevelOuter[3] = float(" << m_tessGenLevel << ");\n"
				"}\n";

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

	// Tessellation evaluation
	{
		std::ostringstream src;
		src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
			<< "#extension GL_EXT_tessellation_shader : require\n"
			<< "layout(quads) in;\n"
			<< "\n"
			<< "layout(location = 0) out mediump ivec2 v_tessellationGridPosition;\n"
			<< "\n"
			<< "// note: No need to use precise gl_Position since position does not depend on order\n"
			<< "void main (void)\n"
			<< "{\n";

		if (m_flags & (FLAG_GEOMETRY_SCATTER_INSTANCES | FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS))
			src << "    // Cover only a small area in a corner. The area will be expanded in geometry shader to cover whole viewport\n"
				<< "    gl_Position = vec4(gl_TessCoord.x * 0.3 - 1.0, gl_TessCoord.y * 0.3 - 1.0, 0.0, 1.0);\n";
		else
			src << "    // Fill the whole viewport\n"
				<< "    gl_Position = vec4(gl_TessCoord.x * 2.0 - 1.0, gl_TessCoord.y * 2.0 - 1.0, 0.0, 1.0);\n";

		src << "    // Calculate position in tessellation grid\n"
			<< "    v_tessellationGridPosition = ivec2(round(gl_TessCoord.xy * float(" << m_tessGenLevel << ")));\n"
			<< "}\n";

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

	// Geometry shader
	{
		const int numInvocations = m_numGeometryInvocations;
		const int numPrimitives  = m_numGeometryPrimitivesPerInvocation;

		std::ostringstream src;

		src	<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
			<< "#extension GL_EXT_geometry_shader : require\n"
			<< "layout(triangles, invocations = " << numInvocations << ") in;\n"
			<< "layout(triangle_strip, max_vertices = " << ((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) ? (4 * numPrimitives) : (numPrimitives + 2)) << ") out;\n"
			<< "\n"
			<< "layout(location = 0) in       mediump ivec2 v_tessellationGridPosition[];\n"
			<< "layout(location = 0) flat out highp   vec4  v_color;\n"
			<< "\n"
			<< "void main (void)\n"
			<< "{\n"
			<< "    const float equalThreshold = 0.001;\n"
			<< "    const float gapOffset = 0.0001; // subdivision performed by the geometry shader might produce gaps. Fill potential gaps by enlarging the output slice a little.\n"
			<< "\n"
			<< "    // Input triangle is generated from an axis-aligned rectangle by splitting it in half\n"
			<< "    // Original rectangle can be found by finding the bounding AABB of the triangle\n"
			<< "    vec4 aabb = vec4(min(gl_in[0].gl_Position.x, min(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
			<< "                     min(gl_in[0].gl_Position.y, min(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)),\n"
			<< "                     max(gl_in[0].gl_Position.x, max(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
			<< "                     max(gl_in[0].gl_Position.y, max(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)));\n"
			<< "\n"
			<< "    // Location in tessellation grid\n"
			<< "    ivec2 gridPosition = ivec2(min(v_tessellationGridPosition[0], min(v_tessellationGridPosition[1], v_tessellationGridPosition[2])));\n"
			<< "\n"
			<< "    // Which triangle of the two that split the grid cell\n"
			<< "    int numVerticesOnBottomEdge = 0;\n"
			<< "    for (int ndx = 0; ndx < 3; ++ndx)\n"
			<< "        if (abs(gl_in[ndx].gl_Position.y - aabb.w) < equalThreshold)\n"
			<< "            ++numVerticesOnBottomEdge;\n"
			<< "    bool isBottomTriangle = numVerticesOnBottomEdge == 2;\n"
			<< "\n";

		if (m_flags & FLAG_GEOMETRY_SCATTER_PRIMITIVES)
		{
			// scatter primitives
			src << "    // Draw grid cells\n"
				<< "    int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
				<< "    for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n"
				<< "    {\n"
				<< "        ivec2 dstGridSize = ivec2(" << m_tessGenLevel << " * " << numPrimitives << ", 2 * " << m_tessGenLevel << " * " << numInvocations << ");\n"
				<< "        ivec2 dstGridNdx = ivec2(" << m_tessGenLevel << " * ndx + gridPosition.x, " << m_tessGenLevel << " * inputTriangleNdx + 2 * gridPosition.y + ndx * 127) % dstGridSize;\n"
				<< "        vec4 dstArea;\n"
				<< "        dstArea.x = float(dstGridNdx.x)   / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
				<< "        dstArea.y = float(dstGridNdx.y)   / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
				<< "        dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
				<< "        dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
				<< "\n"
				<< "        vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "        EndPrimitive();\n"
				<< "    }\n";
		}
		else if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
		{
			// Number of subrectangle instances = num layers
			DE_ASSERT(m_numLayers == numInvocations * 2);

			src << "    // Draw grid cells, send each primitive to a separate layer\n"
				<< "    int baseLayer = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
				<< "    for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n"
				<< "    {\n"
				<< "        ivec2 dstGridSize = ivec2(" << m_tessGenLevel << " * " << numPrimitives << ", " << m_tessGenLevel << ");\n"
				<< "        ivec2 dstGridNdx = ivec2((gridPosition.x * " << numPrimitives << " * 7 + ndx)*13, (gridPosition.y * 127 + ndx) * 19) % dstGridSize;\n"
				<< "        vec4 dstArea;\n"
				<< "        dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
				<< "        dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
				<< "        dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
				<< "        dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
				<< "\n"
				<< "        vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
				<< "        EmitVertex();\n"
				<< "        EndPrimitive();\n"
				<< "    }\n";
		}
		else
		{
			if (m_flags & FLAG_GEOMETRY_SCATTER_INSTANCES)
			{
				src << "    // Scatter slices\n"
					<< "    int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
					<< "    ivec2 srcSliceNdx = ivec2(gridPosition.x, gridPosition.y * " << (numInvocations*2) << " + inputTriangleNdx);\n"
					<< "    ivec2 dstSliceNdx = ivec2(7 * srcSliceNdx.x, 127 * srcSliceNdx.y) % ivec2(" << m_tessGenLevel << ", " << m_tessGenLevel << " * " << (numInvocations*2) << ");\n"
					<< "\n"
					<< "    // Draw slice to the dstSlice slot\n"
					<< "    vec4 outputSliceArea;\n"
					<< "    outputSliceArea.x = float(dstSliceNdx.x)   / float(" << m_tessGenLevel << ") * 2.0 - 1.0 - gapOffset;\n"
					<< "    outputSliceArea.y = float(dstSliceNdx.y)   / float(" << (m_tessGenLevel * numInvocations * 2) << ") * 2.0 - 1.0 - gapOffset;\n"
					<< "    outputSliceArea.z = float(dstSliceNdx.x+1) / float(" << m_tessGenLevel << ") * 2.0 - 1.0 + gapOffset;\n"
					<< "    outputSliceArea.w = float(dstSliceNdx.y+1) / float(" << (m_tessGenLevel * numInvocations * 2) << ") * 2.0 - 1.0 + gapOffset;\n";
			}
			else
			{
				src << "    // Fill the input area with slices\n"
					<< "    // Upper triangle produces slices only to the upper half of the quad and vice-versa\n"
					<< "    float triangleOffset = (isBottomTriangle) ? ((aabb.w + aabb.y) / 2.0) : (aabb.y);\n"
					<< "    // Each slice is a invocation\n"
					<< "    float sliceHeight = (aabb.w - aabb.y) / float(2 * " << numInvocations << ");\n"
					<< "    float invocationOffset = float(gl_InvocationID) * sliceHeight;\n"
					<< "\n"
					<< "    vec4 outputSliceArea;\n"
					<< "    outputSliceArea.x = aabb.x - gapOffset;\n"
					<< "    outputSliceArea.y = triangleOffset + invocationOffset - gapOffset;\n"
					<< "    outputSliceArea.z = aabb.z + gapOffset;\n"
					<< "    outputSliceArea.w = triangleOffset + invocationOffset + sliceHeight + gapOffset;\n";
			}

			src << "\n"
				<< "    // Draw slice\n"
				<< "    for (int ndx = 0; ndx < " << ((numPrimitives+2)/2) << "; ++ndx)\n"
				<< "    {\n"
				<< "        vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
				<< "        vec4 outputColor = (((gl_InvocationID + ndx) % 2) == 0) ? (green) : (yellow);\n"
				<< "        float xpos = mix(outputSliceArea.x, outputSliceArea.z, float(ndx) / float(" << (numPrimitives/2) << "));\n"
				<< "\n"
				<< "        gl_Position = vec4(xpos, outputSliceArea.y, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "\n"
				<< "        gl_Position = vec4(xpos, outputSliceArea.w, 0.0, 1.0);\n"
				<< "        v_color = outputColor;\n"
				<< "        EmitVertex();\n"
				<< "    }\n";
		}

		src <<	"}\n";

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

class GridRenderTestInstance : public TestInstance
{
public:
	struct Params
	{
		Flags	flags;
		int		numLayers;

		Params (void) : flags(), numLayers() {}
	};
						GridRenderTestInstance	(Context& context, const Params& params) : TestInstance(context), m_params(params) {}
	tcu::TestStatus		iterate					(void);

private:
	Params				m_params;
};

TestInstance* GridRenderTestCase::createInstance (Context& context) const
{
	GridRenderTestInstance::Params params;

	params.flags	 = m_flags;
	params.numLayers = m_numLayers;

	return new GridRenderTestInstance(context, params);
}

bool verifyResultLayer (tcu::TestLog& log, const tcu::ConstPixelBufferAccess& image, const int layerNdx)
{
	tcu::Surface errorMask	(image.getWidth(), image.getHeight());
	bool		 foundError	= false;

	tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));

	log << tcu::TestLog::Message << "Verifying output layer " << layerNdx  << tcu::TestLog::EndMessage;

	for (int y = 0; y < image.getHeight(); ++y)
	for (int x = 0; x < image.getWidth(); ++x)
	{
		const int		threshold	= 8;
		const tcu::RGBA	color		(image.getPixel(x, y));

		// Color must be a linear combination of green and yellow
		if (color.getGreen() < 255 - threshold || color.getBlue() > threshold)
		{
			errorMask.setPixel(x, y, tcu::RGBA::red());
			foundError = true;
		}
	}

	if (!foundError)
	{
		log << tcu::TestLog::Message << "Image valid." << tcu::TestLog::EndMessage
			<< tcu::TestLog::ImageSet("ImageVerification", "Image verification")
			<< tcu::TestLog::Image("Result", "Rendered result", image)
			<< tcu::TestLog::EndImageSet;
		return true;
	}
	else
	{
		log	<< tcu::TestLog::Message << "Image verification failed, found invalid pixels." << tcu::TestLog::EndMessage
			<< tcu::TestLog::ImageSet("ImageVerification", "Image verification")
			<< tcu::TestLog::Image("Result", "Rendered result", image)
			<< tcu::TestLog::Image("ErrorMask", "Error mask", errorMask.getAccess())
			<< tcu::TestLog::EndImageSet;
		return false;
	}
}

tcu::TestStatus GridRenderTestInstance::iterate (void)
{
	requireFeatures(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER | FEATURE_GEOMETRY_SHADER);

	m_context.getTestContext().getLog()
		<< tcu::TestLog::Message
		<< "Rendering single point at the origin. Expecting yellow and green colored grid-like image. (High-frequency grid may appear unicolored)."
		<< tcu::TestLog::EndMessage;

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

	// Color attachment

	const tcu::IVec2			  renderSize			   = tcu::IVec2(RENDER_SIZE, RENDER_SIZE);
	const VkFormat				  colorFormat			   = VK_FORMAT_R8G8B8A8_UNORM;
	const VkImageSubresourceRange colorImageAllLayersRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, m_params.numLayers);
	const VkImageCreateInfo		  colorImageCreateInfo	   = makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, m_params.numLayers);
	const VkImageViewType		  colorAttachmentViewType  = (m_params.numLayers == 1 ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
	const Image					  colorAttachmentImage	   (vk, device, allocator, colorImageCreateInfo, MemoryRequirement::Any);

	// Color output buffer: image will be copied here for verification (big enough for all layers).

	const VkDeviceSize	colorBufferSizeBytes	= renderSize.x()*renderSize.y() * m_params.numLayers * tcu::getPixelSize(mapVkFormat(colorFormat));
	const Buffer		colorBuffer				(vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);

	// Pipeline: no vertex input attributes nor descriptors.

	const Unique<VkImageView>		colorAttachmentView(makeImageView						(vk, device, *colorAttachmentImage, colorAttachmentViewType, colorFormat, colorImageAllLayersRange));
	const Unique<VkRenderPass>		renderPass		   (makeRenderPass						(vk, device, colorFormat));
	const Unique<VkFramebuffer>		framebuffer		   (makeFramebuffer						(vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), m_params.numLayers));
	const Unique<VkPipelineLayout>	pipelineLayout	   (makePipelineLayoutWithoutDescriptors(vk, device));
	const Unique<VkCommandPool>		cmdPool			   (makeCommandPool						(vk, device, queueFamilyIndex));
	const Unique<VkCommandBuffer>	cmdBuffer		   (makeCommandBuffer					(vk, device, *cmdPool));

	const Unique<VkPipeline> pipeline (GraphicsPipelineBuilder()
		.setRenderSize	(renderSize)
		.setShader		(vk, device, VK_SHADER_STAGE_VERTEX_BIT,				  m_context.getBinaryCollection().get("vert"), DE_NULL)
		.setShader		(vk, device, VK_SHADER_STAGE_FRAGMENT_BIT,				  m_context.getBinaryCollection().get("frag"), DE_NULL)
		.setShader		(vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,	  m_context.getBinaryCollection().get("tesc"), DE_NULL)
		.setShader		(vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get("tese"), DE_NULL)
		.setShader		(vk, device, VK_SHADER_STAGE_GEOMETRY_BIT,				  m_context.getBinaryCollection().get("geom"), DE_NULL)
		.build			(vk, device, *pipelineLayout, *renderPass));

	beginCommandBuffer(vk, *cmdBuffer);

	// Change color attachment image layout
	{
		const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier(
			(VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
			VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
			*colorAttachmentImage, colorImageAllLayersRange);

		vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u,
			0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier);
	}

	// Begin render pass
	{
		const VkRect2D renderArea = {
			makeOffset2D(0, 0),
			makeExtent2D(renderSize.x(), renderSize.y()),
		};
		const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f);

		beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor);
	}

	vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);

	vk.cmdDraw(*cmdBuffer, 1u, 1u, 0u, 0u);
	endRenderPass(vk, *cmdBuffer);

	// Copy render result to a host-visible buffer
	{
		const VkImageMemoryBarrier colorAttachmentPreCopyBarrier = makeImageMemoryBarrier(
			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
			*colorAttachmentImage, colorImageAllLayersRange);

		vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
			0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentPreCopyBarrier);
	}
	{
		const VkImageSubresourceLayers subresourceLayers = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, m_params.numLayers);
		const VkBufferImageCopy		   copyRegion		 = makeBufferImageCopy(makeExtent3D(renderSize.x(), renderSize.y(), 1), subresourceLayers);
		vk.cmdCopyImageToBuffer(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, &copyRegion);
	}
	{
		const VkBufferMemoryBarrier postCopyBarrier = makeBufferMemoryBarrier(
			VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *colorBuffer, 0ull, colorBufferSizeBytes);

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

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

	// Verify results
	{
		const Allocation& alloc = colorBuffer.getAllocation();
		invalidateMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), colorBufferSizeBytes);

		const tcu::ConstPixelBufferAccess imageAllLayers(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), m_params.numLayers, alloc.getHostPtr());

		bool allOk = true;
		for (int ndx = 0; ndx < m_params.numLayers; ++ndx)
			allOk = allOk && verifyResultLayer(m_context.getTestContext().getLog(),
											   tcu::getSubregion(imageAllLayers, 0, 0, ndx, renderSize.x(), renderSize.y(), 1),
											   ndx);

		return (allOk ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Image comparison failed"));
	}
}

struct TestCaseDescription
{
	const char*	name;
	const char*	desc;
	Flags		flags;
};

} // anonymous

//! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.render.limits.*
//! \note Tests that check implementation defined limits were omitted, because they rely on runtime shader source generation
//!       (e.g. changing the number of vertices output from geometry shader). CTS currently doesn't support that,
//!       because some platforms require precompiled shaders.
tcu::TestCaseGroup* createGeometryGridRenderLimitsTests  (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "limits", "Render with properties near their limits"));

	static const TestCaseDescription cases[] =
	{
		{
			"output_required_max_tessellation",
			"Minimum maximum tessellation level",
			FLAG_TESSELLATION_MAX_SPEC
		},
		{
			"output_required_max_geometry",
			"Output minimum maximum number of vertices the geometry shader",
			FLAG_GEOMETRY_MAX_SPEC
		},
		{
			"output_required_max_invocations",
			"Minimum maximum number of geometry shader invocations",
			FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC
		},
	};

	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx)
		group->addChild(new GridRenderTestCase(testCtx, cases[ndx].name, cases[ndx].desc, cases[ndx].flags));

	return group.release();
}

//! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.render.scatter.*
tcu::TestCaseGroup* createGeometryGridRenderScatterTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "scatter", "Scatter output primitives"));

	static const TestCaseDescription cases[] =
	{
		{
			"geometry_scatter_instances",
			"Each geometry shader instance outputs its primitives far from other instances of the same execution",
			FLAG_GEOMETRY_SCATTER_INSTANCES
		},
		{
			"geometry_scatter_primitives",
			"Each geometry shader instance outputs its primitives far from other primitives of the same instance",
			FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SEPARATE_PRIMITIVES
		},
		{
			"geometry_scatter_layers",
			"Each geometry shader instance outputs its primitives to multiple layers and far from other primitives of the same instance",
			FLAG_GEOMETRY_SCATTER_LAYERS | FLAG_GEOMETRY_SEPARATE_PRIMITIVES
		},
	};

	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx)
		group->addChild(new GridRenderTestCase(testCtx, cases[ndx].name, cases[ndx].desc, cases[ndx].flags));

	return group.release();
}

} // tessellation
} // vkt