/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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 Fragment operation test utilities.
 *//*--------------------------------------------------------------------*/

#include "glsFragmentOpUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluDrawUtil.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"

namespace deqp
{
namespace gls
{
namespace FragmentOpUtil
{

template<typename T>
inline T triQuadInterpolate (const T values[4], float xFactor, float yFactor)
{
	if (xFactor + yFactor < 1.0f)
		return values[0] + (values[2]-values[0])*xFactor		+ (values[1]-values[0])*yFactor;
	else
		return values[3] + (values[1]-values[3])*(1.0f-xFactor)	+ (values[2]-values[3])*(1.0f-yFactor);
}

// GLSL ES 1.0 shaders
static const char* s_glsl1VertSrc =
	"attribute highp vec4 a_position;\n"
	"attribute mediump vec4 a_color;\n"
	"varying mediump vec4 v_color;\n"
	"void main()\n"
	"{\n"
	"	gl_Position = a_position;\n"
	"	v_color = a_color;\n"
	"}\n";
static const char* s_glsl1FragSrc =
	"varying mediump vec4 v_color;\n"
	"void main()\n"
	"{\n"
	"	gl_FragColor = v_color;\n"
	"}\n";

// GLSL ES 3.0 shaders
static const char* s_glsl3VertSrc =
	"#version 300 es\n"
	"in highp vec4 a_position;\n"
	"in mediump vec4 a_color;\n"
	"out mediump vec4 v_color;\n"
	"void main()\n"
	"{\n"
	"	gl_Position = a_position;\n"
	"	v_color = a_color;\n"
	"}\n";
static const char* s_glsl3FragSrc =
	"#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"void main()\n"
	"{\n"
	"	o_color = v_color;\n"
	"}\n";

// GLSL 3.3 shaders
static const char* s_glsl33VertSrc =
	"#version 330 core\n"
	"in vec4 a_position;\n"
	"in vec4 a_color;\n"
	"in vec4 a_color1;\n"
	"out vec4 v_color;\n"
	"out vec4 v_color1;\n"
	"void main()\n"
	"{\n"
	"	gl_Position	= a_position;\n"
	"	v_color		= a_color;\n"
	"	v_color1	= a_color1;\n"
	"}\n";
static const char* s_glsl33FragSrc =
	"#version 330 core\n"
	"in vec4 v_color;\n"
	"in vec4 v_color1;\n"
	"layout(location = 0, index = 0) out vec4 o_color;\n"
	"layout(location = 0, index = 1) out vec4 o_color1;\n"
	"void main()\n"
	"{\n"
	"	o_color  = v_color;\n"
	"	o_color1 = v_color1;\n"
	"}\n";

static const char* getVertSrc (glu::GLSLVersion glslVersion)
{
	if (glslVersion == glu::GLSL_VERSION_100_ES)
		return s_glsl1VertSrc;
	else if (glslVersion == glu::GLSL_VERSION_300_ES)
		return s_glsl3VertSrc;
	else if (glslVersion == glu::GLSL_VERSION_330)
		return s_glsl33VertSrc;

	DE_ASSERT(DE_FALSE);
	return 0;
}

static const char* getFragSrc (glu::GLSLVersion glslVersion)
{
	if (glslVersion == glu::GLSL_VERSION_100_ES)
		return s_glsl1FragSrc;
	else if (glslVersion == glu::GLSL_VERSION_300_ES)
		return s_glsl3FragSrc;
	else if (glslVersion == glu::GLSL_VERSION_330)
		return s_glsl33FragSrc;

	DE_ASSERT(DE_FALSE);
	return 0;
}

QuadRenderer::QuadRenderer (const glu::RenderContext& context, glu::GLSLVersion glslVersion)
	: m_context			(context)
	, m_program			(DE_NULL)
	, m_positionLoc		(0)
	, m_colorLoc		(-1)
	, m_color1Loc		(-1)
	, m_blendFuncExt	(!glu::glslVersionIsES(glslVersion) && (glslVersion >= glu::GLSL_VERSION_330))
{
	DE_ASSERT(glslVersion == glu::GLSL_VERSION_100_ES ||
			  glslVersion == glu::GLSL_VERSION_300_ES ||
			  glslVersion == glu::GLSL_VERSION_330);

	const glw::Functions&	gl		= context.getFunctions();
	const char*				vertSrc	= getVertSrc(glslVersion);
	const char*				fragSrc	= getFragSrc(glslVersion);

	m_program = new glu::ShaderProgram(m_context, glu::makeVtxFragSources(vertSrc, fragSrc));
	if (!m_program->isOk())
	{
		delete m_program;
		throw tcu::TestError("Failed to compile program", DE_NULL, __FILE__, __LINE__);
	}

	m_positionLoc	= gl.getAttribLocation(m_program->getProgram(), "a_position");
	m_colorLoc		= gl.getAttribLocation(m_program->getProgram(), "a_color");

	if (m_blendFuncExt)
		m_color1Loc = gl.getAttribLocation(m_program->getProgram(), "a_color1");

	if (m_positionLoc < 0 || m_colorLoc < 0 || (m_blendFuncExt && m_color1Loc < 0))
	{
		delete m_program;
		throw tcu::TestError("Invalid attribute locations", DE_NULL, __FILE__, __LINE__);
	}
}

QuadRenderer::~QuadRenderer (void)
{
	delete m_program;
}

void QuadRenderer::render (const Quad& quad) const
{
	const float position[] =
	{
		quad.posA.x(), quad.posA.y(), quad.depth[0], 1.0f,
		quad.posA.x(), quad.posB.y(), quad.depth[1], 1.0f,
		quad.posB.x(), quad.posA.y(), quad.depth[2], 1.0f,
		quad.posB.x(), quad.posB.y(), quad.depth[3], 1.0f
	};
	const deUint8 indices[] = { 0, 2, 1, 1, 2, 3 };

	DE_STATIC_ASSERT(sizeof(tcu::Vec4) == sizeof(float)*4);
	DE_STATIC_ASSERT(sizeof(quad.color) == sizeof(float)*4*4);
	DE_STATIC_ASSERT(sizeof(quad.color1) == sizeof(float)*4*4);

	std::vector<glu::VertexArrayBinding> vertexArrays;

	vertexArrays.push_back(glu::va::Float(m_positionLoc,	4, 4, 0, &position[0]));
	vertexArrays.push_back(glu::va::Float(m_colorLoc,		4, 4, 0, (const float*)&quad.color[0]));

	if (m_blendFuncExt)
		vertexArrays.push_back(glu::va::Float(m_color1Loc,	4, 4, 0, (const float*)&quad.color1[0]));

	m_context.getFunctions().useProgram(m_program->getProgram());
	glu::draw(m_context, m_program->getProgram(),
			  (int)vertexArrays.size(), &vertexArrays[0],
			  glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
}

ReferenceQuadRenderer::ReferenceQuadRenderer (void)
	: m_fragmentBufferSize(0)
{
	for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_fragmentDepths); i++)
		m_fragmentDepths[i] = 0.0f;
}

void ReferenceQuadRenderer::flushFragmentBuffer (const rr::MultisamplePixelBufferAccess&	colorBuffer,
												 const rr::MultisamplePixelBufferAccess&	depthBuffer,
												 const rr::MultisamplePixelBufferAccess&	stencilBuffer,
												 rr::FaceType								faceType,
												 const rr::FragmentOperationState&			state)
{
	m_fragmentProcessor.render(colorBuffer, depthBuffer, stencilBuffer, &m_fragmentBuffer[0], m_fragmentBufferSize, faceType, state);
	m_fragmentBufferSize = 0;
}

void ReferenceQuadRenderer::render (const tcu::PixelBufferAccess&			colorBuffer,
									const tcu::PixelBufferAccess&			depthBuffer,
									const tcu::PixelBufferAccess&			stencilBuffer,
									const IntegerQuad&						quad,
									const rr::FragmentOperationState&		state)
{
	bool			flipX			= quad.posA.x() > quad.posB.x();
	bool			flipY			= quad.posA.y() > quad.posB.y();
	rr::FaceType	faceType		= flipX == flipY ? rr::FACETYPE_FRONT : rr::FACETYPE_BACK;
	int				xFirst			= flipX ? quad.posB.x() : quad.posA.x();
	int				xLast			= flipX ? quad.posA.x() : quad.posB.x();
	int				yFirst			= flipY ? quad.posB.y() : quad.posA.y();
	int				yLast			= flipY ? quad.posA.y() : quad.posB.y();
	float			width			= (float)(xLast - xFirst + 1);
	float			height			= (float)(yLast - yFirst + 1);

	for (int y = yFirst; y <= yLast; y++)
	{
		// Interpolation factor for y.
		float yRatio = (0.5f + (float)(y - yFirst)) / height;
		if (flipY)
			yRatio = 1.0f - yRatio;

		for (int x = xFirst; x <= xLast; x++)
		{
			// Interpolation factor for x.
			float xRatio = (0.5f + (float)(x - xFirst)) / width;
			if (flipX)
				xRatio = 1.0f - xRatio;

			tcu::Vec4	color	= triQuadInterpolate(quad.color, xRatio, yRatio);
			tcu::Vec4	color1	= triQuadInterpolate(quad.color1, xRatio, yRatio);
			float		depth	= triQuadInterpolate(quad.depth, xRatio, yRatio);

			// Interpolated color and depth.

			DE_STATIC_ASSERT(MAX_FRAGMENT_BUFFER_SIZE == DE_LENGTH_OF_ARRAY(m_fragmentBuffer));

			if (m_fragmentBufferSize >= MAX_FRAGMENT_BUFFER_SIZE)
				flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
									rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
									rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);

			m_fragmentDepths[m_fragmentBufferSize] = depth;
			m_fragmentBuffer[m_fragmentBufferSize] = rr::Fragment(tcu::IVec2(x, y), rr::GenericVec4(color), rr::GenericVec4(color1), 1u /* coverage mask */, &m_fragmentDepths[m_fragmentBufferSize]);
			m_fragmentBufferSize++;
		}
	}

	flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
						rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
						rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);
}

tcu::PixelBufferAccess getMultisampleAccess(const tcu::PixelBufferAccess& original)
{
	return tcu::PixelBufferAccess(original.getFormat(),
								  1,
								  original.getWidth(),
								  original.getHeight(),
								  original.getFormat().getPixelSize(),
								  original.getRowPitch(),
								  original.getDataPtr());
}

tcu::ConstPixelBufferAccess getMultisampleAccess(const tcu::ConstPixelBufferAccess& original)
{
	return tcu::ConstPixelBufferAccess(original.getFormat(),
									   1,
									   original.getWidth(),
									   original.getHeight(),
									   original.getFormat().getPixelSize(),
									   original.getRowPitch(),
									   original.getDataPtr());
}

} // FragmentOpUtil
} // gls
} // deqp