modules/glshared/glsFragOpInteractionCase.cpp

/*-------------------------------------------------------------------------
 * 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 Shader - render state interaction case.
 *//*--------------------------------------------------------------------*/

#include "glsFragOpInteractionCase.hpp"

#include "glsRandomShaderProgram.hpp"
#include "glsFragmentOpUtil.hpp"
#include "glsInteractionTestUtil.hpp"

#include "gluRenderContext.hpp"
#include "gluContextInfo.hpp"

#include "rsgShader.hpp"
#include "rsgProgramGenerator.hpp"
#include "rsgUtils.hpp"

#include "sglrContext.hpp"
#include "sglrReferenceContext.hpp"
#include "sglrGLContext.hpp"
#include "sglrContextUtil.hpp"

#include "tcuRenderTarget.hpp"
#include "tcuImageCompare.hpp"

#include "deRandom.hpp"
#include "deString.h"
#include "deStringUtil.hpp"

#include "glwEnums.hpp"

#include "gluDrawUtil.hpp"

namespace deqp
{
namespace gls
{

using std::vector;
using std::string;
using tcu::Vec2;
using tcu::Vec4;
using tcu::IVec2;
using tcu::IVec4;

using gls::InteractionTestUtil::RenderState;
using gls::InteractionTestUtil::StencilState;

enum
{
	NUM_ITERATIONS					= 5,
	NUM_COMMANDS_PER_ITERATION		= 5,
	VIEWPORT_WIDTH					= 64,
	VIEWPORT_HEIGHT					= 64
};

namespace
{

static void computeVertexLayout (const vector<rsg::ShaderInput*>& attributes, int numVertices, vector<glu::VertexArrayBinding>* layout, int* stride)
{
	DE_ASSERT(layout->empty());

	int curOffset = 0;

	for (vector<rsg::ShaderInput*>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
	{
		const rsg::ShaderInput*		attrib		= *iter;
		const rsg::Variable*		var			= attrib->getVariable();
		const rsg::VariableType&	type		= var->getType();
		const int					numComps	= type.getNumElements();

		TCU_CHECK_INTERNAL(type.getBaseType() == rsg::VariableType::TYPE_FLOAT && de::inRange(type.getNumElements(), 1, 4));

		layout->push_back(glu::va::Float(var->getName(), numComps, numVertices, 0 /* computed later */, (const float*)(deUintptr)curOffset));

		curOffset += numComps * (int)sizeof(float);
	}

	for (vector<glu::VertexArrayBinding>::iterator vaIter = layout->begin(); vaIter != layout->end(); ++vaIter)
		vaIter->pointer.stride = curOffset;

	*stride = curOffset;
}

class VertexDataStorage
{
public:
												VertexDataStorage	(const vector<rsg::ShaderInput*>& attributes, int numVertices);

	int											getDataSize			(void) const	{ return (int)m_data.size();					}
	void*										getBasePtr			(void)			{ return m_data.empty() ? DE_NULL : &m_data[0]; }
	const void*									getBasePtr			(void) const	{ return m_data.empty() ? DE_NULL : &m_data[0]; }

	const std::vector<glu::VertexArrayBinding>&	getLayout			(void) const	{ return m_layout; }

	int											getNumEntries		(void) const	{ return (int)m_layout.size();	}
	const glu::VertexArrayBinding&				getLayoutEntry		(int ndx) const	{ return m_layout[ndx];			}

private:
	std::vector<deUint8>						m_data;
	std::vector<glu::VertexArrayBinding>		m_layout;
};

VertexDataStorage::VertexDataStorage (const vector<rsg::ShaderInput*>& attributes, int numVertices)
{
	int stride = 0;
	computeVertexLayout(attributes, numVertices, &m_layout, &stride);
	m_data.resize(stride * numVertices);
}

static inline glu::VertexArrayBinding getEntryWithPointer (const VertexDataStorage& data, int ndx)
{
	const glu::VertexArrayBinding& entry = data.getLayoutEntry(ndx);
	return glu::VertexArrayBinding(entry.binding, glu::VertexArrayPointer(entry.pointer.componentType,
																		  entry.pointer.convert,
																		  entry.pointer.numComponents,
																		  entry.pointer.numElements,
																		  entry.pointer.stride,
																		  (const void*)((deUintptr)entry.pointer.data+(deUintptr)data.getBasePtr())));
}

template<int Size>
static void setVertex (const glu::VertexArrayPointer& pointer, int vertexNdx, const tcu::Vector<float, Size>& value)
{
	// \todo [2013-12-14 pyry] Implement other modes.
	DE_ASSERT(pointer.componentType == glu::VTX_COMP_FLOAT && pointer.convert == glu::VTX_COMP_CONVERT_NONE);
	DE_ASSERT(pointer.numComponents == Size);
	DE_ASSERT(de::inBounds(vertexNdx, 0, pointer.numElements));

	float* dst = (float*)((deUint8*)pointer.data + pointer.stride*vertexNdx);

	for (int ndx = 0; ndx < Size; ndx++)
		dst[ndx] = value[ndx];
}

template<int Size>
static tcu::Vector<float, Size> interpolateRange (const rsg::ConstValueRangeAccess& range, const tcu::Vector<float, Size>& t)
{
	tcu::Vector<float, Size> result;

	for (int ndx = 0; ndx < Size; ndx++)
		result[ndx] = range.getMin().component(ndx).asFloat()*(1.0f - t[ndx]) + range.getMax().component(ndx).asFloat()*t[ndx];

	return result;
}

struct Quad
{
	tcu::IVec2	posA;
	tcu::IVec2	posB;
};

struct RenderCommand
{
	Quad		quad;
	float		depth;
	RenderState	state;

	RenderCommand (void) : depth(0.0f) {}
};

static Quad getRandomQuad (de::Random& rnd, int targetW, int targetH)
{
	// \note In viewport coordinates.
	// \todo [2012-12-18 pyry] Out-of-bounds values.
	const int		maxOutOfBounds	= 0;
	const float		minSize			= 0.5f;

	const int		minW			= deCeilFloatToInt32(minSize * (float)targetW);
	const int		minH			= deCeilFloatToInt32(minSize * (float)targetH);
	const int		maxW			= targetW + 2*maxOutOfBounds;
	const int		maxH			= targetH + 2*maxOutOfBounds;

	const int		width			= rnd.getInt(minW, maxW);
	const int		height			= rnd.getInt(minH, maxH);
	const int		x				= rnd.getInt(-maxOutOfBounds, targetW+maxOutOfBounds-width);
	const int		y				= rnd.getInt(-maxOutOfBounds, targetH+maxOutOfBounds-height);

	const bool		flipX			= rnd.getBool();
	const bool		flipY			= rnd.getBool();

	Quad			quad;

	quad.posA	= tcu::IVec2(flipX ? (x+width-1) : x, flipY ? (y+height-1) : y);
	quad.posB	= tcu::IVec2(flipX ? x : (x+width-1), flipY ? y : (y+height-1));

	return quad;
}

static float getRandomDepth (de::Random& rnd)
{
	// \note Not using depth 1.0 since clearing with 1.0 and rendering with 1.0 may not be same value.
	static const float depthValues[] = { 0.0f, 0.2f, 0.4f, 0.5f, 0.51f, 0.6f, 0.8f, 0.95f };
	return rnd.choose<float>(DE_ARRAY_BEGIN(depthValues), DE_ARRAY_END(depthValues));
}

static void computeRandomRenderCommand (de::Random& rnd, RenderCommand& command, glu::ApiType apiType, int targetW, int targetH)
{
	command.quad	= getRandomQuad(rnd, targetW, targetH);
	command.depth	= getRandomDepth(rnd);
	gls::InteractionTestUtil::computeRandomRenderState(rnd, command.state, apiType, targetW, targetH);
}

static void setRenderState (sglr::Context& ctx, const RenderState& state)
{
	if (state.scissorTestEnabled)
	{
		ctx.enable(GL_SCISSOR_TEST);
		ctx.scissor(state.scissorRectangle.left, state.scissorRectangle.bottom,
					state.scissorRectangle.width, state.scissorRectangle.height);
	}
	else
		ctx.disable(GL_SCISSOR_TEST);

	if (state.stencilTestEnabled)
	{
		ctx.enable(GL_STENCIL_TEST);

		for (int face = 0; face < rr::FACETYPE_LAST; face++)
		{
			deUint32				glFace	= face == rr::FACETYPE_BACK ? GL_BACK : GL_FRONT;
			const StencilState&		sParams	= state.stencil[face];

			ctx.stencilFuncSeparate(glFace, sParams.function, sParams.reference, sParams.compareMask);
			ctx.stencilOpSeparate(glFace, sParams.stencilFailOp, sParams.depthFailOp, sParams.depthPassOp);
			ctx.stencilMaskSeparate(glFace, sParams.writeMask);
		}
	}
	else
		ctx.disable(GL_STENCIL_TEST);

	if (state.depthTestEnabled)
	{
		ctx.enable(GL_DEPTH_TEST);
		ctx.depthFunc(state.depthFunc);
		ctx.depthMask(state.depthWriteMask ? GL_TRUE : GL_FALSE);
	}
	else
		ctx.disable(GL_DEPTH_TEST);

	if (state.blendEnabled)
	{
		ctx.enable(GL_BLEND);
		ctx.blendEquationSeparate(state.blendRGBState.equation, state.blendAState.equation);
		ctx.blendFuncSeparate(state.blendRGBState.srcFunc, state.blendRGBState.dstFunc, state.blendAState.srcFunc, state.blendAState.dstFunc);
		ctx.blendColor(state.blendColor.x(), state.blendColor.y(), state.blendColor.z(), state.blendColor.w());
	}
	else
		ctx.disable(GL_BLEND);

	if (state.ditherEnabled)
		ctx.enable(GL_DITHER);
	else
		ctx.disable(GL_DITHER);

	ctx.colorMask(state.colorMask[0] ? GL_TRUE : GL_FALSE,
				  state.colorMask[1] ? GL_TRUE : GL_FALSE,
				  state.colorMask[2] ? GL_TRUE : GL_FALSE,
				  state.colorMask[3] ? GL_TRUE : GL_FALSE);
}

static void renderQuad (sglr::Context& ctx, const glu::VertexArrayPointer& posPtr, const Quad& quad, const float depth)
{
	const deUint16	indices[]	= { 0, 1, 2, 2, 1, 3 };

	const bool		flipX		= quad.posB.x() < quad.posA.x();
	const bool		flipY		= quad.posB.y() < quad.posA.y();
	const int		viewportX	= de::min(quad.posA.x(), quad.posB.x());
	const int		viewportY	= de::min(quad.posA.y(), quad.posB.y());
	const int		viewportW	= de::abs(quad.posA.x()-quad.posB.x())+1;
	const int		viewportH	= de::abs(quad.posA.y()-quad.posB.y())+1;

	const Vec2		pA			(flipX ? 1.0f : -1.0f, flipY ? 1.0f : -1.0f);
	const Vec2		pB			(flipX ? -1.0f : 1.0f, flipY ? -1.0f : 1.0f);

	setVertex(posPtr, 0, Vec4(pA.x(), pA.y(), depth, 1.0f));
	setVertex(posPtr, 1, Vec4(pB.x(), pA.y(), depth, 1.0f));
	setVertex(posPtr, 2, Vec4(pA.x(), pB.y(), depth, 1.0f));
	setVertex(posPtr, 3, Vec4(pB.x(), pB.y(), depth, 1.0f));

	ctx.viewport(viewportX, viewportY, viewportW, viewportH);
	ctx.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0]);
}

static void render (sglr::Context& ctx, const glu::VertexArrayPointer& posPtr, const RenderCommand& cmd)
{
	setRenderState(ctx, cmd.state);
	renderQuad(ctx, posPtr, cmd.quad, cmd.depth);
}

static void setupAttributes (sglr::Context& ctx, const VertexDataStorage& vertexData, deUint32 program)
{
	for (int attribNdx = 0; attribNdx < vertexData.getNumEntries(); ++attribNdx)
	{
		const glu::VertexArrayBinding	bindingPtr	= getEntryWithPointer(vertexData, attribNdx);
		const int						attribLoc	= bindingPtr.binding.type == glu::BindingPoint::BPTYPE_NAME ? ctx.getAttribLocation(program, bindingPtr.binding.name.c_str()) : bindingPtr.binding.location;

		DE_ASSERT(bindingPtr.pointer.componentType == glu::VTX_COMP_FLOAT);

		if (attribLoc >= 0)
		{
			ctx.enableVertexAttribArray(attribLoc);
			ctx.vertexAttribPointer(attribLoc, bindingPtr.pointer.numComponents, GL_FLOAT, GL_FALSE, bindingPtr.pointer.stride, bindingPtr.pointer.data);
		}
	}
}

void setUniformValue (sglr::Context& ctx, int location, rsg::ConstValueAccess value)
{
	DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(float));
	DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(int));

	switch (value.getType().getBaseType())
	{
		case rsg::VariableType::TYPE_FLOAT:
			switch (value.getType().getNumElements())
			{
				case 1:		ctx.uniform1fv(location, 1, (float*)value.value().getValuePtr());	break;
				case 2:		ctx.uniform2fv(location, 1, (float*)value.value().getValuePtr());	break;
				case 3:		ctx.uniform3fv(location, 1, (float*)value.value().getValuePtr());	break;
				case 4:		ctx.uniform4fv(location, 1, (float*)value.value().getValuePtr());	break;
				default:	TCU_FAIL("Unsupported type");										break;
			}
			break;

		case rsg::VariableType::TYPE_INT:
		case rsg::VariableType::TYPE_BOOL:
		case rsg::VariableType::TYPE_SAMPLER_2D:
		case rsg::VariableType::TYPE_SAMPLER_CUBE:
			switch (value.getType().getNumElements())
			{
				case 1:		ctx.uniform1iv(location, 1, (int*)value.value().getValuePtr());		break;
				case 2:		ctx.uniform2iv(location, 1, (int*)value.value().getValuePtr());		break;
				case 3:		ctx.uniform3iv(location, 1, (int*)value.value().getValuePtr());		break;
				case 4:		ctx.uniform4iv(location, 1, (int*)value.value().getValuePtr());		break;
				default:	TCU_FAIL("Unsupported type");										break;
			}
			break;

		default:
			throw tcu::InternalError("Unsupported type", "", __FILE__, __LINE__);
	}
}

static int findShaderInputIndex (const vector<rsg::ShaderInput*>& vars, const char* name)
{
	for (int ndx = 0; ndx < (int)vars.size(); ++ndx)
	{
		if (deStringEqual(vars[ndx]->getVariable()->getName(), name))
			return ndx;
	}

	throw tcu::InternalError(string(name) + " not found in shader inputs");
}

static float getWellBehavingChannelColor (float v, int numBits)
{
	DE_ASSERT(de::inRange(numBits, 0, 32));

	// clear color may not be accurately representable in the target format. If the clear color is
	// on a representable value mapping range border, it could be rounded differently by the GL and in
	// SGLR adding an unexpected error source. However, selecting an accurately representable background
	// color would effectively disable dithering. To allow dithering and to prevent undefined rounding
	// direction from affecting results, round accurate color to target color format with 8 sub-units
	// (3 bits). If the selected sub-unit value is 3 or 4 (bordering 0.5), replace it with 2 and 5,
	// respectively.

	if (numBits == 0 || v <= 0.0f || v >= 1.0f)
	{
		// already accurately representable
		return v;
	}
	else
	{
		const deUint64 numSubBits		= 3;
		const deUint64 subUnitBorderLo	= (1u << (numSubBits - 1u)) - 1u;
		const deUint64 subUnitBorderHi	= 1u << (numSubBits - 1u);
		const deUint64 maxFixedValue	= (1u << (numBits + numSubBits)) - 1u;
		const deUint64 fixedValue		= deRoundFloatToInt64(v * (float)maxFixedValue);

		const deUint64 units			= fixedValue >> numSubBits;
		const deUint64 subUnits			= fixedValue & ((1u << numSubBits) - 1u);

		const deUint64 tweakedSubUnits	= (subUnits == subUnitBorderLo) ? (subUnitBorderLo - 1)
										: (subUnits == subUnitBorderHi) ? (subUnitBorderHi + 1)
										: (subUnits);
		const deUint64 tweakedValue		= (units << numSubBits) | (tweakedSubUnits);

		return float(tweakedValue) / float(maxFixedValue);
	}
}

static tcu::Vec4 getWellBehavingColor (const tcu::Vec4& accurateColor, const tcu::PixelFormat& format)
{
	return tcu::Vec4(getWellBehavingChannelColor(accurateColor[0], format.redBits),
					 getWellBehavingChannelColor(accurateColor[1], format.greenBits),
					 getWellBehavingChannelColor(accurateColor[2], format.blueBits),
					 getWellBehavingChannelColor(accurateColor[3], format.alphaBits));
}

} // anonymous

struct FragOpInteractionCase::ReferenceContext
{
	const sglr::ReferenceContextLimits	limits;
	sglr::ReferenceContextBuffers		buffers;
	sglr::ReferenceContext				context;

	ReferenceContext (glu::RenderContext& renderCtx, int width, int height)
		: limits	(renderCtx)
		, buffers	(renderCtx.getRenderTarget().getPixelFormat(), renderCtx.getRenderTarget().getDepthBits(), renderCtx.getRenderTarget().getStencilBits(), width, height)
		, context	(limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer())
	{
	}
};

FragOpInteractionCase::FragOpInteractionCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const rsg::ProgramParameters& params)
	: TestCase			(testCtx, name, "")
	, m_renderCtx		(renderCtx)
	, m_ctxInfo			(ctxInfo)
	, m_params			(params)
	, m_vertexShader	(rsg::Shader::TYPE_VERTEX)
	, m_fragmentShader	(rsg::Shader::TYPE_FRAGMENT)
	, m_program			(DE_NULL)
	, m_glCtx			(DE_NULL)
	, m_referenceCtx	(DE_NULL)
	, m_glProgram		(0)
	, m_refProgram		(0)
	, m_iterNdx			(0)
{
}

FragOpInteractionCase::~FragOpInteractionCase (void)
{
	FragOpInteractionCase::deinit();
}

void FragOpInteractionCase::init (void)
{
	de::Random				rnd				(m_params.seed ^ 0x232faac);
	const int				viewportW		= de::min<int>(m_renderCtx.getRenderTarget().getWidth(),	VIEWPORT_WIDTH);
	const int				viewportH		= de::min<int>(m_renderCtx.getRenderTarget().getHeight(),	VIEWPORT_HEIGHT);
	const int				viewportX		= rnd.getInt(0, m_renderCtx.getRenderTarget().getWidth()	- viewportW);
	const int				viewportY		= rnd.getInt(0, m_renderCtx.getRenderTarget().getHeight()	- viewportH);

	rsg::ProgramGenerator	generator;

	generator.generate(m_params, m_vertexShader, m_fragmentShader);
	rsg::computeUnifiedUniforms(m_vertexShader, m_fragmentShader, m_unifiedUniforms);

	try
	{
		DE_ASSERT(!m_program);
		m_program = new gls::RandomShaderProgram(m_vertexShader, m_fragmentShader, (int)m_unifiedUniforms.size(), m_unifiedUniforms.empty() ? DE_NULL : &m_unifiedUniforms[0]);

		DE_ASSERT(!m_referenceCtx);
		m_referenceCtx = new ReferenceContext(m_renderCtx, viewportW, viewportH);

		DE_ASSERT(!m_glCtx);
		m_glCtx = new sglr::GLContext(m_renderCtx, m_testCtx.getLog(), sglr::GLCONTEXT_LOG_CALLS|sglr::GLCONTEXT_LOG_PROGRAMS, IVec4(viewportX, viewportY, viewportW, viewportH));

		m_refProgram	= m_referenceCtx->context.createProgram(m_program);
		m_glProgram		= m_glCtx->createProgram(m_program);

		m_viewportSize	= tcu::IVec2(viewportW, viewportH);
		m_iterNdx		= 0;
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	catch (...)
	{
		// Save some memory by cleaning up stuff.
		FragOpInteractionCase::deinit();
		throw;
	}
}

void FragOpInteractionCase::deinit (void)
{
	delete m_referenceCtx;
	m_referenceCtx = DE_NULL;

	delete m_glCtx;
	m_glCtx = DE_NULL;

	delete m_program;
	m_program = DE_NULL;
}

FragOpInteractionCase::IterateResult FragOpInteractionCase::iterate (void)
{
	de::Random							rnd					(m_params.seed ^ deInt32Hash(m_iterNdx));
	const tcu::ScopedLogSection			section				(m_testCtx.getLog(), string("Iter") + de::toString(m_iterNdx), string("Iteration ") + de::toString(m_iterNdx));

	const int							positionNdx			= findShaderInputIndex(m_vertexShader.getInputs(), "dEQP_Position");

	const int							numVertices			= 4;
	VertexDataStorage					vertexData			(m_vertexShader.getInputs(), numVertices);
	std::vector<rsg::VariableValue>		uniformValues;
	std::vector<RenderCommand>			renderCmds			(NUM_COMMANDS_PER_ITERATION);

	tcu::Surface						rendered			(m_viewportSize.x(), m_viewportSize.y());
	tcu::Surface						reference			(m_viewportSize.x(), m_viewportSize.y());

	const tcu::Vec4						vtxInterpFactors[]	=
	{
		tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
		tcu::Vec4(1.0f, 0.0f, 0.5f, 0.5f),
		tcu::Vec4(0.0f, 1.0f, 0.5f, 0.5f),
		tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)
	};

	rsg::computeUniformValues(rnd, uniformValues, m_unifiedUniforms);

	for (int attribNdx = 0; attribNdx < (int)m_vertexShader.getInputs().size(); ++attribNdx)
	{
		if (attribNdx == positionNdx)
			continue;

		const rsg::ShaderInput*				shaderIn		= m_vertexShader.getInputs()[attribNdx];
		const rsg::VariableType&			varType			= shaderIn->getVariable()->getType();
		const rsg::ConstValueRangeAccess	valueRange		= shaderIn->getValueRange();
		const int							numComponents	= varType.getNumElements();
		const glu::VertexArrayBinding		layoutEntry		= getEntryWithPointer(vertexData, attribNdx);

		DE_ASSERT(varType.getBaseType() == rsg::VariableType::TYPE_FLOAT);

		for (int vtxNdx = 0; vtxNdx < 4; vtxNdx++)
		{
			const int			fNdx	= (attribNdx+vtxNdx+m_iterNdx)%DE_LENGTH_OF_ARRAY(vtxInterpFactors);
			const tcu::Vec4&	f		= vtxInterpFactors[fNdx];

			switch (numComponents)
			{
				case 1:	setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<1>()));	break;
				case 2:	setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<2>()));	break;
				case 3:	setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<3>()));	break;
				case 4:	setVertex(layoutEntry.pointer, vtxNdx, interpolateRange(valueRange, f.toWidth<4>()));	break;
				default:
					DE_ASSERT(false);
			}
		}
	}

	for (vector<RenderCommand>::iterator cmdIter = renderCmds.begin(); cmdIter != renderCmds.end(); ++cmdIter)
		computeRandomRenderCommand(rnd, *cmdIter, m_renderCtx.getType().getAPI(), m_viewportSize.x(), m_viewportSize.y());

	// Workaround for inaccurate barycentric/depth computation in current reference renderer:
	// Small bias is added to the draw call depths, in increasing order, to avoid accuracy issues in depth comparison.
	for (int cmdNdx = 0; cmdNdx < (int)renderCmds.size(); cmdNdx++)
		renderCmds[cmdNdx].depth += 0.0231725f * float(cmdNdx);

	{
		const glu::VertexArrayPointer		posPtr				= getEntryWithPointer(vertexData, positionNdx).pointer;

		sglr::Context* const				contexts[]			= { m_glCtx, &m_referenceCtx->context };
		const deUint32						programs[]			= { m_glProgram, m_refProgram };
		tcu::PixelBufferAccess				readDst[]			= { rendered.getAccess(), reference.getAccess() };

		const tcu::Vec4						accurateClearColor	= tcu::Vec4(0.0f, 0.25f, 0.5f, 1.0f);
		const tcu::Vec4						clearColor			= getWellBehavingColor(accurateClearColor, m_renderCtx.getRenderTarget().getPixelFormat());

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(contexts); ndx++)
		{
			sglr::Context&	ctx			= *contexts[ndx];
			const deUint32	program		= programs[ndx];

			setupAttributes(ctx, vertexData, program);

			ctx.disable		(GL_SCISSOR_TEST);
			ctx.colorMask	(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
			ctx.depthMask	(GL_TRUE);
			ctx.stencilMask	(~0u);
			ctx.clearColor	(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
			ctx.clear		(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);

			ctx.useProgram	(program);

			for (vector<rsg::VariableValue>::const_iterator uniformIter = uniformValues.begin(); uniformIter != uniformValues.end(); ++uniformIter)
				setUniformValue(ctx, ctx.getUniformLocation(program, uniformIter->getVariable()->getName()), uniformIter->getValue());

			for (vector<RenderCommand>::const_iterator cmdIter = renderCmds.begin(); cmdIter != renderCmds.end(); ++cmdIter)
				render(ctx, posPtr, *cmdIter);

			GLU_EXPECT_NO_ERROR(ctx.getError(), "Rendering failed");

			ctx.readPixels(0, 0, m_viewportSize.x(), m_viewportSize.y(), GL_RGBA, GL_UNSIGNED_BYTE, readDst[ndx].getDataPtr());
		}
	}

	{
		const tcu::RGBA		threshold		= m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold()+tcu::RGBA(3,3,3,3);
		const bool			compareOk		= tcu::bilinearCompare(m_testCtx.getLog(), "CompareResult", "Image comparison result", reference.getAccess(), rendered.getAccess(), threshold, tcu::COMPARE_LOG_RESULT);

		if (!compareOk)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
			return STOP;
		}
	}

	m_iterNdx += 1;
	return (m_iterNdx < NUM_ITERATIONS) ? CONTINUE : STOP;
}

} // gls
} // deqp