#ifndef _GLSFRAGMENTOPUTIL_HPP
#define _GLSFRAGMENTOPUTIL_HPP
/*-------------------------------------------------------------------------
 * 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 "tcuDefs.hpp"
#include "gluShaderUtil.hpp"
#include "tcuVector.hpp"
#include "tcuTexture.hpp"
#include "rrFragmentOperations.hpp"

namespace glu
{
class ShaderProgram;
class RenderContext;
}

namespace deqp
{
namespace gls
{
namespace FragmentOpUtil
{

struct Quad
{
	tcu::Vec2		posA;
	tcu::Vec2		posB;

	// Normalized device coordinates (range [-1, 1]).
	// In order (A.x, A.y), (A.x, B.y), (B.x, A.y), (B.x, B.y)
	tcu::Vec4		color[4];
	tcu::Vec4		color1[4];
	float			depth[4];

	Quad (void)
		: posA(-1.0f, -1.0f)
		, posB( 1.0f,  1.0f)
	{
		for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
			depth[i] = 0.0f;
	}
};

class QuadRenderer
{
public:
								QuadRenderer				(const glu::RenderContext& context, glu::GLSLVersion glslVersion);
								~QuadRenderer				(void);

	void						render						(const Quad& quad) const;

private:
								QuadRenderer				(const QuadRenderer& other); // Not allowed!
	QuadRenderer&				operator=					(const QuadRenderer& other); // Not allowed!

	const glu::RenderContext&	m_context;
	glu::ShaderProgram*			m_program;
	int							m_positionLoc;
	int							m_colorLoc;
	int							m_color1Loc;
	const bool					m_blendFuncExt;
};

struct IntegerQuad
{
	tcu::IVec2	posA;
	tcu::IVec2	posB;

	// Viewport coordinates (depth in range [0, 1]).
	// In order (A.x, A.y), (A.x, B.y), (B.x, A.y), (B.x, B.y)
	tcu::Vec4	color[4];
	tcu::Vec4	color1[4];
	float		depth[4];

	IntegerQuad (int windowWidth, int windowHeight)
		: posA(0,				0)
		, posB(windowWidth-1,	windowHeight-1)
	{
		for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
			depth[i] = 0.0f;
	}

	IntegerQuad (void)
		: posA(0, 0)
		, posB(1, 1)
	{
		for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
			depth[i] = 0.0f;
	}
};

class ReferenceQuadRenderer
{
public:
								ReferenceQuadRenderer	(void);

	void						render					(const tcu::PixelBufferAccess&			colorBuffer,
														 const tcu::PixelBufferAccess&			depthBuffer,
														 const tcu::PixelBufferAccess&			stencilBuffer,
														 const IntegerQuad&						quad,
														 const rr::FragmentOperationState&		state);

private:
	enum
	{
		MAX_FRAGMENT_BUFFER_SIZE = 1024
	};

	void						flushFragmentBuffer (const rr::MultisamplePixelBufferAccess&	colorBuffer,
													 const rr::MultisamplePixelBufferAccess&	depthBuffer,
													 const rr::MultisamplePixelBufferAccess&	stencilBuffer,
													 rr::FaceType								faceType,
													 const rr::FragmentOperationState&			state);

	rr::Fragment				m_fragmentBuffer[MAX_FRAGMENT_BUFFER_SIZE];
	float						m_fragmentDepths[MAX_FRAGMENT_BUFFER_SIZE];
	int							m_fragmentBufferSize;

	rr::FragmentProcessor		m_fragmentProcessor;
};


// These functions take a normally-indexed 2d pixel buffer and return a pixel buffer access
// that indexes the same memory area, but using the multisample indexing convention.
tcu::PixelBufferAccess					getMultisampleAccess(const tcu::PixelBufferAccess&			original);
tcu::ConstPixelBufferAccess				getMultisampleAccess(const tcu::ConstPixelBufferAccess&	original);

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

#endif // _GLSFRAGMENTOPUTIL_HPP