Home | History | Annotate | Download | only in functional
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 3.1 Module
      3  * -------------------------------------------------
      4  *
      5  * Copyright 2015 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Indexed blend operation tests (GL_EXT_draw_buffers_indexed)
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es31fDrawBuffersIndexedTests.hpp"
     25 
     26 #include "gluContextInfo.hpp"
     27 #include "gluDrawUtil.hpp"
     28 #include "gluObjectWrapper.hpp"
     29 #include "gluPixelTransfer.hpp"
     30 #include "gluShaderProgram.hpp"
     31 #include "gluStrUtil.hpp"
     32 #include "gluTextureUtil.hpp"
     33 
     34 #include "sglrReferenceUtils.hpp"
     35 
     36 #include "rrMultisamplePixelBufferAccess.hpp"
     37 #include "rrRenderer.hpp"
     38 
     39 #include "glwEnums.hpp"
     40 #include "glwFunctions.hpp"
     41 
     42 #include "tcuEither.hpp"
     43 #include "tcuImageCompare.hpp"
     44 #include "tcuMaybe.hpp"
     45 #include "tcuResultCollector.hpp"
     46 #include "tcuStringTemplate.hpp"
     47 #include "tcuTestLog.hpp"
     48 #include "tcuTexture.hpp"
     49 #include "tcuTextureUtil.hpp"
     50 #include "tcuVector.hpp"
     51 #include "tcuVectorUtil.hpp"
     52 #include "tcuFloat.hpp"
     53 
     54 #include "deRandom.hpp"
     55 #include "deArrayUtil.hpp"
     56 #include "deStringUtil.hpp"
     57 #include "deUniquePtr.hpp"
     58 
     59 #include "deInt32.h"
     60 
     61 #include <string>
     62 #include <vector>
     63 #include <map>
     64 
     65 using tcu::BVec4;
     66 using tcu::Either;
     67 using tcu::IVec2;
     68 using tcu::IVec4;
     69 using tcu::Maybe;
     70 using tcu::TestLog;
     71 using tcu::TextureFormat;
     72 using tcu::TextureLevel;
     73 using tcu::UVec4;
     74 using tcu::Vec2;
     75 using tcu::Vec4;
     76 using tcu::just;
     77 
     78 using std::string;
     79 using std::vector;
     80 using std::map;
     81 
     82 using sglr::rr_util::mapGLBlendEquation;
     83 using sglr::rr_util::mapGLBlendFunc;
     84 using sglr::rr_util::mapGLBlendEquationAdvanced;
     85 
     86 namespace deqp
     87 {
     88 namespace gles31
     89 {
     90 namespace Functional
     91 {
     92 namespace
     93 {
     94 
     95 typedef deUint32 BlendEq;
     96 
     97 bool isAdvancedBlendEq (BlendEq eq)
     98 {
     99 	switch (eq)
    100 	{
    101 		case GL_MULTIPLY:		return true;
    102 		case GL_SCREEN:			return true;
    103 		case GL_OVERLAY:		return true;
    104 		case GL_DARKEN:			return true;
    105 		case GL_LIGHTEN:		return true;
    106 		case GL_COLORDODGE:		return true;
    107 		case GL_COLORBURN:		return true;
    108 		case GL_HARDLIGHT:		return true;
    109 		case GL_SOFTLIGHT:		return true;
    110 		case GL_DIFFERENCE:		return true;
    111 		case GL_EXCLUSION:		return true;
    112 		case GL_HSL_HUE:		return true;
    113 		case GL_HSL_SATURATION:	return true;
    114 		case GL_HSL_COLOR:		return true;
    115 		case GL_HSL_LUMINOSITY:	return true;
    116 		default:
    117 			return false;
    118 	}
    119 }
    120 
    121 struct SeparateBlendEq
    122 {
    123 	SeparateBlendEq (BlendEq rgb_, BlendEq alpha_)
    124 		: rgb	(rgb_)
    125 		, alpha	(alpha_)
    126 	{
    127 	}
    128 
    129 	BlendEq rgb;
    130 	BlendEq alpha;
    131 };
    132 
    133 struct BlendFunc
    134 {
    135 	BlendFunc (deUint32 src_, deUint32 dst_)
    136 		: src (src_)
    137 		, dst (dst_)
    138 	{
    139 	}
    140 
    141 	deUint32 src;
    142 	deUint32 dst;
    143 };
    144 
    145 struct SeparateBlendFunc
    146 {
    147 	SeparateBlendFunc (BlendFunc rgb_, BlendFunc alpha_)
    148 		: rgb	(rgb_)
    149 		, alpha	(alpha_)
    150 	{
    151 	}
    152 
    153 	BlendFunc rgb;
    154 	BlendFunc alpha;
    155 };
    156 
    157 typedef deUint32 DrawBuffer;
    158 
    159 struct BlendState
    160 {
    161 	BlendState (void) {}
    162 
    163 	BlendState (const Maybe<bool>&									enableBlend_,
    164 				const Maybe<Either<BlendEq, SeparateBlendEq> >&		blendEq_,
    165 				const Maybe<Either<BlendFunc, SeparateBlendFunc> >&	blendFunc_,
    166 				const Maybe<BVec4>&									colorMask_)
    167 		: enableBlend	(enableBlend_)
    168 		, blendEq		(blendEq_)
    169 		, blendFunc		(blendFunc_)
    170 		, colorMask		(colorMask_)
    171 	{
    172 	}
    173 
    174 	bool isEmpty (void) const
    175 	{
    176 		return (!enableBlend) && (!blendEq) && (!blendFunc) && (!colorMask);
    177 	}
    178 
    179 	Maybe<bool>										enableBlend;
    180 	Maybe<Either<BlendEq, SeparateBlendEq> >		blendEq;
    181 	Maybe<Either<BlendFunc, SeparateBlendFunc> >	blendFunc;
    182 	Maybe<BVec4>									colorMask;
    183 };
    184 
    185 void setCommonBlendState (const glw::Functions& gl, const BlendState& blend)
    186 {
    187 	if (blend.enableBlend)
    188 	{
    189 		if (*blend.enableBlend)
    190 			gl.enable(GL_BLEND);
    191 		else
    192 			gl.disable(GL_BLEND);
    193 	}
    194 
    195 	if (blend.colorMask)
    196 	{
    197 		const BVec4& mask = *blend.colorMask;
    198 
    199 		gl.colorMask(mask.x(), mask.y(), mask.z(), mask.w());
    200 	}
    201 
    202 	if (blend.blendEq)
    203 	{
    204 		const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
    205 
    206 		if (blendEq.is<BlendEq>())
    207 			gl.blendEquation(blendEq.get<BlendEq>());
    208 		else if (blendEq.is<SeparateBlendEq>())
    209 			gl.blendEquationSeparate(blendEq.get<SeparateBlendEq>().rgb, blendEq.get<SeparateBlendEq>().alpha);
    210 		else
    211 			DE_ASSERT(false);
    212 	}
    213 
    214 	if (blend.blendFunc)
    215 	{
    216 		const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
    217 
    218 		if (blendFunc.is<BlendFunc>())
    219 			gl.blendFunc(blendFunc.get<BlendFunc>().src, blendFunc.get<BlendFunc>().dst);
    220 		else if (blendFunc.is<SeparateBlendFunc>())
    221 			gl.blendFuncSeparate(blendFunc.get<SeparateBlendFunc>().rgb.src, blendFunc.get<SeparateBlendFunc>().rgb.dst, blendFunc.get<SeparateBlendFunc>().alpha.src, blendFunc.get<SeparateBlendFunc>().alpha.dst);
    222 		else
    223 			DE_ASSERT(false);
    224 	}
    225 
    226 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set common blend state.");
    227 }
    228 
    229 void setIndexedBlendState (const glw::Functions& gl, const BlendState& blend, deUint32 index)
    230 {
    231 	if (blend.enableBlend)
    232 	{
    233 		if (*blend.enableBlend)
    234 			gl.enablei(GL_BLEND, index);
    235 		else
    236 			gl.disablei(GL_BLEND, index);
    237 	}
    238 
    239 	if (blend.colorMask)
    240 	{
    241 		const BVec4 mask = *blend.colorMask;
    242 
    243 		gl.colorMaski(index, mask.x(), mask.y(), mask.z(), mask.w());
    244 	}
    245 
    246 	if (blend.blendEq)
    247 	{
    248 		const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
    249 
    250 		if (blendEq.is<BlendEq>())
    251 			gl.blendEquationi(index, blendEq.get<BlendEq>());
    252 		else if (blendEq.is<SeparateBlendEq>())
    253 			gl.blendEquationSeparatei(index, blendEq.get<SeparateBlendEq>().rgb, blendEq.get<SeparateBlendEq>().alpha);
    254 		else
    255 			DE_ASSERT(false);
    256 	}
    257 
    258 	if (blend.blendFunc)
    259 	{
    260 		const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
    261 
    262 		if (blendFunc.is<BlendFunc>())
    263 			gl.blendFunci(index, blendFunc.get<BlendFunc>().src, blendFunc.get<BlendFunc>().dst);
    264 		else if (blendFunc.is<SeparateBlendFunc>())
    265 			gl.blendFuncSeparatei(index, blendFunc.get<SeparateBlendFunc>().rgb.src, blendFunc.get<SeparateBlendFunc>().rgb.dst, blendFunc.get<SeparateBlendFunc>().alpha.src, blendFunc.get<SeparateBlendFunc>().alpha.dst);
    266 		else
    267 			DE_ASSERT(false);
    268 	}
    269 
    270 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set draw buffer specifig blend state.");
    271 }
    272 
    273 class DrawBufferInfo
    274 {
    275 public:
    276 							DrawBufferInfo	(bool					render,
    277 											 const IVec2&			size,
    278 											 const BlendState&		blendState,
    279 											 const TextureFormat&	format);
    280 
    281 	const TextureFormat&	getFormat		(void) const { return m_format;		}
    282 	const IVec2&			getSize			(void) const { return m_size;		}
    283 	const BlendState&		getBlendState	(void) const { return m_blendState;	}
    284 	bool					getRender		(void) const { return m_render;		}
    285 
    286 private:
    287 	bool					m_render;
    288 	IVec2					m_size;
    289 	TextureFormat			m_format;
    290 	BlendState				m_blendState;
    291 };
    292 
    293 DrawBufferInfo::DrawBufferInfo (bool render, const IVec2& size, const BlendState& blendState, const TextureFormat& format)
    294 	: m_render		(render)
    295 	, m_size		(size)
    296 	, m_format		(format)
    297 	, m_blendState	(blendState)
    298 {
    299 }
    300 
    301 void clearRenderbuffer (const glw::Functions&			gl,
    302 						const tcu::TextureFormat&		format,
    303 						int								renderbufferNdx,
    304 						int								renderbufferCount,
    305 						tcu::TextureLevel&				refRenderbuffer)
    306 {
    307 	const tcu::TextureFormatInfo	info		= tcu::getTextureFormatInfo(format);
    308 
    309 	// Clear each buffer to different color
    310 	const float						redScale	= float(renderbufferNdx + 1) / float(renderbufferCount);
    311 	const float						blueScale	= float(renderbufferCount - renderbufferNdx) / float(renderbufferCount);
    312 	const float						greenScale	= float(((renderbufferCount/2) + renderbufferNdx) % renderbufferCount) / float(renderbufferCount);
    313 	// Alpha should never be zero as advanced blend equations assume premultiplied alpha.
    314 	const float						alphaScale	= float(1 + (((renderbufferCount/2) + renderbufferCount - renderbufferNdx) % renderbufferCount)) / float(renderbufferCount);
    315 
    316 	switch (tcu::getTextureChannelClass(format.type))
    317 	{
    318 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    319 		{
    320 			const float red		= -1000.0f + 2000.0f * redScale;
    321 			const float green	= -1000.0f + 2000.0f * greenScale;
    322 			const float blue	= -1000.0f + 2000.0f * blueScale;
    323 			const float alpha	= -1000.0f + 2000.0f * alphaScale;
    324 			const Vec4	color	(red, green, blue, alpha);
    325 
    326 			tcu::clear(refRenderbuffer, color);
    327 			gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
    328 			break;
    329 		}
    330 
    331 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    332 		{
    333 			const deInt32	red		= deInt32(info.valueMin.x() + (info.valueMax.x() - info.valueMin.x()) * redScale);
    334 			const deInt32	green	= deInt32(info.valueMin.y() + (info.valueMax.y() - info.valueMin.y()) * greenScale);
    335 			const deInt32	blue	= deInt32(info.valueMin.z() + (info.valueMax.z() - info.valueMin.z()) * blueScale);
    336 			const deInt32	alpha	= deInt32(info.valueMin.w() + (info.valueMax.w() - info.valueMin.w()) * alphaScale);
    337 			const IVec4		color	(red, green, blue, alpha);
    338 
    339 			tcu::clear(refRenderbuffer, color);
    340 			gl.clearBufferiv(GL_COLOR, renderbufferNdx, color.getPtr());
    341 			break;
    342 		}
    343 
    344 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    345 		{
    346 			const deUint32	red		= deUint32(info.valueMax.x() * redScale);
    347 			const deUint32	green	= deUint32(info.valueMax.y() * greenScale);
    348 			const deUint32	blue	= deUint32(info.valueMax.z() * blueScale);
    349 			const deUint32	alpha	= deUint32(info.valueMax.w() * alphaScale);
    350 			const UVec4		color	(red, green, blue, alpha);
    351 
    352 			tcu::clear(refRenderbuffer, color);
    353 			gl.clearBufferuiv(GL_COLOR, renderbufferNdx, color.getPtr());
    354 			break;
    355 		}
    356 
    357 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    358 		{
    359 			const float red		= info.valueMin.x() + (info.valueMax.x() - info.valueMin.x()) * redScale;
    360 			const float green	= info.valueMin.y() + (info.valueMax.y() - info.valueMin.y()) * greenScale;
    361 			const float blue	= info.valueMin.z() + (info.valueMax.z() - info.valueMin.z()) * blueScale;
    362 			const float alpha	= info.valueMin.w() + (info.valueMax.w() - info.valueMin.w()) * alphaScale;
    363 			const Vec4	color	(red, green, blue, alpha);
    364 
    365 			tcu::clear(refRenderbuffer, color);
    366 			gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
    367 			break;
    368 		}
    369 
    370 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    371 		{
    372 			const float red		= info.valueMax.x() * redScale;
    373 			const float green	= info.valueMax.y() * greenScale;
    374 			const float blue	= info.valueMax.z() * blueScale;
    375 			const float alpha	= info.valueMax.w() * alphaScale;
    376 			const Vec4	color	(red, green, blue, alpha);
    377 
    378 			tcu::clear(refRenderbuffer, color);
    379 			gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
    380 			break;
    381 		}
    382 
    383 		default:
    384 			DE_ASSERT(DE_FALSE);
    385 	}
    386 
    387 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer.");
    388 }
    389 
    390 void genRenderbuffers (const glw::Functions&			gl,
    391 						const vector<DrawBufferInfo>&	drawBuffers,
    392 						const glu::Framebuffer&			framebuffer,
    393 						const glu::RenderbufferVector&	renderbuffers,
    394 						vector<TextureLevel>&			refRenderbuffers)
    395 {
    396 	vector<deUint32> bufs;
    397 
    398 	bufs.resize(drawBuffers.size());
    399 
    400 	DE_ASSERT(drawBuffers.size() == renderbuffers.size());
    401 	DE_ASSERT(drawBuffers.size() == refRenderbuffers.size());
    402 
    403 	gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
    404 
    405 	for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
    406 	{
    407 		const DrawBufferInfo&		drawBuffer	= drawBuffers[renderbufferNdx];
    408 		const TextureFormat&		format		= drawBuffer.getFormat();
    409 		const IVec2&				size		= drawBuffer.getSize();
    410 		const deUint32				glFormat	= glu::getInternalFormat(format);
    411 
    412 		bufs[renderbufferNdx]					= GL_COLOR_ATTACHMENT0 + renderbufferNdx;
    413 		refRenderbuffers[renderbufferNdx]		= TextureLevel(drawBuffer.getFormat(), size.x(), size.y());
    414 
    415 		gl.bindRenderbuffer(GL_RENDERBUFFER, renderbuffers[renderbufferNdx]);
    416 		gl.renderbufferStorage(GL_RENDERBUFFER, glFormat, size.x(), size.y());
    417 		gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + renderbufferNdx, GL_RENDERBUFFER, renderbuffers[renderbufferNdx]);
    418 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create renderbuffer.");
    419 	}
    420 
    421 	gl.drawBuffers((glw::GLsizei)bufs.size(), &(bufs[0]));
    422 
    423 	for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
    424 	{
    425 		const DrawBufferInfo&		drawBuffer	= drawBuffers[renderbufferNdx];
    426 		const TextureFormat&		format		= drawBuffer.getFormat();
    427 
    428 		clearRenderbuffer(gl, format, renderbufferNdx, (int)refRenderbuffers.size(),  refRenderbuffers[renderbufferNdx]);
    429 	}
    430 
    431 	gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
    432 	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
    433 }
    434 
    435 Vec4 getFixedPointFormatThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat)
    436 {
    437 	DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT);
    438 	DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT);
    439 
    440 	DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER);
    441 	DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER);
    442 
    443 	DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
    444 	DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
    445 
    446 	const tcu::IVec4	srcBits		= tcu::getTextureFormatBitDepth(sourceFormat);
    447 	const tcu::IVec4	readBits	= tcu::getTextureFormatBitDepth(readPixelsFormat);
    448 
    449 	return Vec4(3.0f) / ((tcu::Vector<deUint64, 4>(1) << (tcu::min(srcBits, readBits).cast<deUint64>())) - tcu::Vector<deUint64, 4>(1)).cast<float>();
    450 }
    451 
    452 UVec4 getFloatULPThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat)
    453 {
    454 	const tcu::IVec4	srcMantissaBits		= tcu::getTextureFormatMantissaBitDepth(sourceFormat);
    455 	const tcu::IVec4	readMantissaBits	= tcu::getTextureFormatMantissaBitDepth(readPixelsFormat);
    456 	tcu::IVec4			ULPDiff(0);
    457 
    458 	for (int i = 0; i < 4; i++)
    459 		if (readMantissaBits[i] >= srcMantissaBits[i])
    460 			ULPDiff[i] = readMantissaBits[i] - srcMantissaBits[i];
    461 
    462 	return UVec4(4) * (UVec4(1) << (ULPDiff.cast<deUint32>()));
    463 }
    464 
    465 void verifyRenderbuffer (TestLog&					log,
    466 						 tcu::ResultCollector&		results,
    467 						 const tcu::TextureFormat&	format,
    468 						 int						renderbufferNdx,
    469 						 const tcu::TextureLevel&	refRenderbuffer,
    470 						 const tcu::TextureLevel&	result)
    471 {
    472 	switch (tcu::getTextureChannelClass(format.type))
    473 	{
    474 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    475 		{
    476 			const string	name		= "Renderbuffer" + de::toString(renderbufferNdx);
    477 			const string	desc		= "Compare renderbuffer " + de::toString(renderbufferNdx);
    478 			const UVec4		threshold	= getFloatULPThreshold(format, result.getFormat());
    479 
    480 			if (!tcu::floatUlpThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
    481 				results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
    482 
    483 			break;
    484 		}
    485 
    486 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    487 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    488 		{
    489 			const string	name		= "Renderbuffer" + de::toString(renderbufferNdx);
    490 			const string	desc		= "Compare renderbuffer " + de::toString(renderbufferNdx);
    491 			const UVec4		threshold	(1, 1, 1, 1);
    492 
    493 			if (!tcu::intThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
    494 				results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
    495 
    496 			break;
    497 		}
    498 
    499 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    500 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    501 		{
    502 			const string	name		= "Renderbuffer" + de::toString(renderbufferNdx);
    503 			const string	desc		= "Compare renderbuffer " + de::toString(renderbufferNdx);
    504 			const Vec4		threshold	= getFixedPointFormatThreshold(format, result.getFormat());
    505 
    506 			if (!tcu::floatThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
    507 				results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
    508 
    509 			break;
    510 		}
    511 
    512 		default:
    513 			DE_ASSERT(DE_FALSE);
    514 	}
    515 }
    516 
    517 TextureFormat getReadPixelFormat (const TextureFormat& format)
    518 {
    519 	switch (tcu::getTextureChannelClass(format.type))
    520 	{
    521 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    522 			return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32);
    523 
    524 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    525 			return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32);
    526 
    527 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    528 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    529 			return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
    530 
    531 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    532 			return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT);
    533 
    534 		default:
    535 			DE_ASSERT(false);
    536 			return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
    537 	}
    538 }
    539 
    540 void verifyRenderbuffers (TestLog&							log,
    541 							tcu::ResultCollector&				results,
    542 							glu::RenderContext&				renderContext,
    543 							const glu::RenderbufferVector&	renderbuffers,
    544 							const glu::Framebuffer&			framebuffer,
    545 							const vector<TextureLevel>&		refRenderbuffers)
    546 {
    547 	const glw::Functions& gl = renderContext.getFunctions();
    548 
    549 	DE_ASSERT(renderbuffers.size() == refRenderbuffers.size());
    550 
    551 	gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
    552 
    553 	for (int renderbufferNdx = 0; renderbufferNdx < (int)renderbuffers.size(); renderbufferNdx++)
    554 	{
    555 		const TextureLevel&	refRenderbuffer	= refRenderbuffers[renderbufferNdx];
    556 		const int			width			= refRenderbuffer.getWidth();
    557 		const int			height			= refRenderbuffer.getHeight();
    558 		const TextureFormat	format			= refRenderbuffer.getFormat();
    559 
    560 		tcu::TextureLevel	result			(getReadPixelFormat(format), width, height);
    561 
    562 		gl.readBuffer(GL_COLOR_ATTACHMENT0 + renderbufferNdx);
    563 		glu::readPixels(renderContext, 0, 0, result.getAccess());
    564 		GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels from renderbuffer failed.");
    565 
    566 		verifyRenderbuffer(log, results, format, renderbufferNdx, refRenderbuffer, result);
    567 	}
    568 
    569 	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
    570 }
    571 
    572 static const float s_quadCoords[] =
    573 {
    574 	-0.5f, -0.5f,
    575 	 0.5f, -0.5f,
    576 	 0.5f,  0.5f,
    577 
    578 	 0.5f,  0.5f,
    579 	-0.5f,  0.5f,
    580 	-0.5f, -0.5f
    581 };
    582 
    583 void setBlendState (rr::FragmentOperationState& fragOps, const BlendState& state)
    584 {
    585 	if (state.blendEq)
    586 	{
    587 		if (state.blendEq->is<BlendEq>())
    588 		{
    589 			if (isAdvancedBlendEq(state.blendEq->get<BlendEq>()))
    590 			{
    591 				const rr::BlendEquationAdvanced	equation = mapGLBlendEquationAdvanced(state.blendEq->get<BlendEq>());
    592 
    593 				fragOps.blendMode				= rr::BLENDMODE_ADVANCED;
    594 				fragOps.blendEquationAdvaced	= equation;
    595 			}
    596 			else
    597 			{
    598 				const rr::BlendEquation equation = mapGLBlendEquation(state.blendEq->get<BlendEq>());
    599 
    600 				fragOps.blendMode				= rr::BLENDMODE_STANDARD;
    601 				fragOps.blendRGBState.equation	= equation;
    602 				fragOps.blendAState.equation	= equation;
    603 			}
    604 		}
    605 		else
    606 		{
    607 			DE_ASSERT(state.blendEq->is<SeparateBlendEq>());
    608 
    609 			fragOps.blendMode				= rr::BLENDMODE_STANDARD;
    610 			fragOps.blendRGBState.equation	= mapGLBlendEquation(state.blendEq->get<SeparateBlendEq>().rgb);
    611 			fragOps.blendAState.equation	= mapGLBlendEquation(state.blendEq->get<SeparateBlendEq>().alpha);
    612 		}
    613 	}
    614 
    615 	if (state.blendFunc)
    616 	{
    617 		if (state.blendFunc->is<BlendFunc>())
    618 		{
    619 			const rr::BlendFunc srcFunction = mapGLBlendFunc(state.blendFunc->get<BlendFunc>().src);
    620 			const rr::BlendFunc dstFunction = mapGLBlendFunc(state.blendFunc->get<BlendFunc>().dst);
    621 
    622 			fragOps.blendRGBState.srcFunc	= srcFunction;
    623 			fragOps.blendRGBState.dstFunc	= dstFunction;
    624 
    625 			fragOps.blendAState.srcFunc		= srcFunction;
    626 			fragOps.blendAState.dstFunc		= dstFunction;
    627 		}
    628 		else
    629 		{
    630 			DE_ASSERT(state.blendFunc->is<SeparateBlendFunc>());
    631 
    632 			fragOps.blendRGBState.srcFunc	= mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().rgb.src);
    633 			fragOps.blendRGBState.dstFunc	= mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().rgb.dst);
    634 
    635 			fragOps.blendAState.srcFunc		= mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().alpha.src);
    636 			fragOps.blendAState.dstFunc		= mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().alpha.dst);
    637 		}
    638 	}
    639 
    640 	if (state.colorMask)
    641 		fragOps.colorMask = *state.colorMask;
    642 }
    643 
    644 rr::RenderState createRenderState (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const DrawBufferInfo& info)
    645 {
    646 	const IVec2		size	= info.getSize();
    647 	rr::RenderState	state	(rr::ViewportState(rr::WindowRectangle(0, 0, size.x(), size.y())));
    648 
    649 	state.fragOps.blendMode = rr::BLENDMODE_STANDARD;
    650 
    651 	setBlendState(state.fragOps, preCommonBlendState);
    652 	setBlendState(state.fragOps, info.getBlendState());
    653 	setBlendState(state.fragOps, postCommonBlendState);
    654 
    655 	if (postCommonBlendState.enableBlend)
    656 		state.fragOps.blendMode = (*(postCommonBlendState.enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
    657 	else  if (info.getBlendState().enableBlend)
    658 		state.fragOps.blendMode = (*(info.getBlendState().enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
    659 	else if (preCommonBlendState.enableBlend)
    660 		state.fragOps.blendMode = (*(preCommonBlendState.enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
    661 	else
    662 		state.fragOps.blendMode = rr::BLENDMODE_NONE;
    663 
    664 	if (tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
    665 		&& tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT
    666 		&& tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
    667 		state.fragOps.blendMode = rr::BLENDMODE_NONE;
    668 
    669 	return state;
    670 }
    671 
    672 class VertexShader : public rr::VertexShader
    673 {
    674 public:
    675 					VertexShader	(void);
    676 	virtual void	shadeVertices	(const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const;
    677 };
    678 
    679 VertexShader::VertexShader (void)
    680 	: rr::VertexShader	(1, 1)
    681 {
    682 	m_inputs[0].type	= rr::GENERICVECTYPE_FLOAT;
    683 	m_outputs[0].type	= rr::GENERICVECTYPE_FLOAT;
    684 }
    685 
    686 void VertexShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
    687 {
    688 	for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
    689 	{
    690 		rr::VertexPacket& packet = *packets[packetNdx];
    691 
    692 		packet.position		= rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
    693 		packet.outputs[0]	= 0.5f * (Vec4(1.0f) + rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx));
    694 	}
    695 }
    696 
    697 class FragmentShader : public rr::FragmentShader
    698 {
    699 public:
    700 			FragmentShader	(int drawBufferNdx, const DrawBufferInfo& info);
    701 	void	shadeFragments	(rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const;
    702 
    703 private:
    704 	const int				m_drawBufferNdx;
    705 	const DrawBufferInfo	m_info;
    706 };
    707 
    708 FragmentShader::FragmentShader (int drawBufferNdx, const DrawBufferInfo& info)
    709 	: rr::FragmentShader	(1, 1)
    710 	, m_drawBufferNdx		(drawBufferNdx)
    711 	, m_info				(info)
    712 {
    713 	m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
    714 
    715 	switch (tcu::getTextureChannelClass(m_info.getFormat().type))
    716 	{
    717 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    718 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    719 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    720 			m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
    721 			break;
    722 
    723 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    724 			m_outputs[0].type = rr::GENERICVECTYPE_UINT32;
    725 			break;
    726 
    727 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    728 			m_outputs[0].type = rr::GENERICVECTYPE_INT32;
    729 			break;
    730 
    731 		default:
    732 			DE_ASSERT(false);
    733 	};
    734 }
    735 
    736 void FragmentShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
    737 {
    738 	for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
    739 	{
    740 		rr::FragmentPacket& packet = packets[packetNdx];
    741 
    742 		DE_ASSERT(m_drawBufferNdx >= 0);
    743 		DE_UNREF(m_info);
    744 
    745 		for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
    746 		{
    747 			const Vec2	vColor		= rr::readVarying<float>(packet, context, 0, fragNdx).xy();
    748 			const float	values[]	=
    749 			{
    750 				vColor.x(),
    751 				vColor.y(),
    752 				(1.0f - vColor.x()),
    753 				(1.0f - vColor.y())
    754 			};
    755 
    756 			switch (tcu::getTextureChannelClass(m_info.getFormat().type))
    757 			{
    758 				case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    759 				case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    760 				case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    761 				{
    762 					const Vec4 color (values[(m_drawBufferNdx + 0) % 4],
    763 									  values[(m_drawBufferNdx + 1) % 4],
    764 									  values[(m_drawBufferNdx + 2) % 4],
    765 									  values[(m_drawBufferNdx + 3) % 4]);
    766 
    767 					rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
    768 					break;
    769 				}
    770 
    771 				case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    772 				{
    773 					const UVec4 color ((deUint32)(values[(m_drawBufferNdx + 0) % 4]),
    774 									   (deUint32)(values[(m_drawBufferNdx + 1) % 4]),
    775 									   (deUint32)(values[(m_drawBufferNdx + 2) % 4]),
    776 									   (deUint32)(values[(m_drawBufferNdx + 3) % 4]));
    777 
    778 					rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
    779 					break;
    780 				}
    781 
    782 				case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    783 				{
    784 					const IVec4 color ((deInt32)(values[(m_drawBufferNdx + 0) % 4]),
    785 									   (deInt32)(values[(m_drawBufferNdx + 1) % 4]),
    786 									   (deInt32)(values[(m_drawBufferNdx + 2) % 4]),
    787 									   (deInt32)(values[(m_drawBufferNdx + 3) % 4]));
    788 
    789 					rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
    790 					break;
    791 				}
    792 
    793 				default:
    794 					DE_ASSERT(DE_FALSE);
    795 			};
    796 		}
    797 	}
    798 }
    799 
    800 rr::VertexAttrib createVertexAttrib (const float* coords)
    801 {
    802 	rr::VertexAttrib attrib;
    803 
    804 	attrib.type		= rr::VERTEXATTRIBTYPE_FLOAT;
    805 	attrib.size		= 2;
    806 	attrib.pointer	= coords;
    807 
    808 	return attrib;
    809 }
    810 
    811 void renderRefQuad (const BlendState&				preCommonBlendState,
    812 					const BlendState&				postCommonBlendState,
    813 					const vector<DrawBufferInfo>&	drawBuffers,
    814 					vector<TextureLevel>&			refRenderbuffers)
    815 {
    816 	const rr::Renderer			renderer;
    817 	const rr::PrimitiveList		primitives		(rr::PRIMITIVETYPE_TRIANGLES, 6, 0);
    818 	const rr::VertexAttrib		vertexAttribs[] =
    819 	{
    820 		createVertexAttrib(s_quadCoords)
    821 	};
    822 
    823 	for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
    824 	{
    825 		if (drawBuffers[drawBufferNdx].getRender())
    826 		{
    827 			const rr::RenderState	renderState		(createRenderState(preCommonBlendState, postCommonBlendState, drawBuffers[drawBufferNdx]));
    828 			const rr::RenderTarget	renderTarget	(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(refRenderbuffers[drawBufferNdx].getAccess()));
    829 			const VertexShader		vertexShader;
    830 			const FragmentShader	fragmentShader	(drawBufferNdx, drawBuffers[drawBufferNdx]);
    831 			const rr::Program		program			(&vertexShader, &fragmentShader);
    832 			const rr::DrawCommand	command			(renderState, renderTarget, program, DE_LENGTH_OF_ARRAY(vertexAttribs), vertexAttribs, primitives);
    833 
    834 			renderer.draw(command);
    835 		}
    836 	}
    837 }
    838 
    839 bool requiresAdvancedBlendEq (const BlendState& pre, const BlendState post, const vector<DrawBufferInfo>& drawBuffers)
    840 {
    841 	bool requiresAdvancedBlendEq = false;
    842 
    843 	if (pre.blendEq && pre.blendEq->is<BlendEq>())
    844 		requiresAdvancedBlendEq |= isAdvancedBlendEq(pre.blendEq->get<BlendEq>());
    845 
    846 	if (post.blendEq && post.blendEq->is<BlendEq>())
    847 		requiresAdvancedBlendEq |= isAdvancedBlendEq(post.blendEq->get<BlendEq>());
    848 
    849 	for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
    850 	{
    851 		const BlendState& drawBufferBlendState = drawBuffers[drawBufferNdx].getBlendState();
    852 
    853 		if (drawBufferBlendState.blendEq && drawBufferBlendState.blendEq->is<BlendEq>())
    854 			requiresAdvancedBlendEq |= isAdvancedBlendEq(drawBufferBlendState.blendEq->get<BlendEq>());
    855 	}
    856 
    857 	return requiresAdvancedBlendEq;
    858 }
    859 
    860 glu::VertexSource genVertexSource (glu::RenderContext& renderContext)
    861 {
    862 	const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
    863 
    864 	const char* const vertexSource =
    865 		"${GLSL_VERSION_DECL}\n"
    866 		"layout(location=0) in highp vec2 i_coord;\n"
    867 		"out highp vec2 v_color;\n"
    868 		"void main (void)\n"
    869 		"{\n"
    870 		"\tv_color = 0.5 * (vec2(1.0) + i_coord);\n"
    871 		"\tgl_Position = vec4(i_coord, 0.0, 1.0);\n"
    872 		"}";
    873 
    874 	map<string, string> args;
    875 	args["GLSL_VERSION_DECL"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    876 
    877 	return glu::VertexSource(tcu::StringTemplate(vertexSource).specialize(args));
    878 }
    879 
    880 glu::FragmentSource genFragmentSource (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const vector<DrawBufferInfo>& drawBuffers, glu::RenderContext& renderContext)
    881 {
    882 	std::ostringstream stream;
    883 	const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
    884 
    885 	stream << "${GLSL_VERSION_DECL}\n";
    886 
    887 	if (requiresAdvancedBlendEq(preCommonBlendState, postCommonBlendState, drawBuffers))
    888 	{
    889 		stream << "${GLSL_EXTENSION}"
    890 			   <<  "layout(blend_support_all_equations) out;\n";
    891 	}
    892 
    893 	stream << "in highp vec2 v_color;\n";
    894 
    895 	for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
    896 	{
    897 		const DrawBufferInfo&	drawBuffer			= drawBuffers[drawBufferNdx];
    898 		const TextureFormat&	format				= drawBuffer.getFormat();
    899 
    900 		stream << "layout(location=" << drawBufferNdx << ") out highp ";
    901 
    902 		switch (tcu::getTextureChannelClass(format.type))
    903 		{
    904 			case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    905 			case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    906 			case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    907 				stream << "vec4";
    908 				break;
    909 
    910 			case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    911 				stream << "uvec4";
    912 				break;
    913 
    914 			case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    915 				stream << "ivec4";
    916 				break;
    917 
    918 			default:
    919 				DE_ASSERT(DE_FALSE);
    920 		};
    921 
    922 		stream << " o_drawBuffer" <<  drawBufferNdx << ";\n";
    923 	}
    924 
    925 	stream << "void main (void)\n"
    926 		   << "{\n";
    927 
    928 	for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
    929 	{
    930 		const DrawBufferInfo&	drawBuffer		= drawBuffers[drawBufferNdx];
    931 		const TextureFormat&	format			= drawBuffer.getFormat();
    932 		const char* const		values[]		=
    933 		{
    934 			"v_color.x",
    935 			"v_color.y",
    936 			"(1.0 - v_color.x)",
    937 			"(1.0 - v_color.y)"
    938 		};
    939 
    940 		stream << "\to_drawBuffer" <<  drawBufferNdx;
    941 
    942 		switch (tcu::getTextureChannelClass(format.type))
    943 		{
    944 			case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    945 			case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    946 			case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    947 				stream << " = vec4(" << values[(drawBufferNdx + 0) % 4]
    948 					   << ", " << values[(drawBufferNdx + 1) % 4]
    949 					   << ", " << values[(drawBufferNdx + 2) % 4]
    950 					   << ", " << values[(drawBufferNdx + 3) % 4] << ");\n";
    951 				break;
    952 
    953 			case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    954 				stream << " = uvec4(uint(" << values[(drawBufferNdx + 0) % 4]
    955 					   << "), uint(" << values[(drawBufferNdx + 1) % 4]
    956 					   << "), uint(" << values[(drawBufferNdx + 2) % 4]
    957 					   << "), uint(" << values[(drawBufferNdx + 3) % 4] << "));\n";
    958 				break;
    959 
    960 			case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    961 				stream << " = ivec4(int(" << values[(drawBufferNdx + 0) % 4]
    962 					   << "), int(" << values[(drawBufferNdx + 1) % 4]
    963 					   << "), int(" << values[(drawBufferNdx + 2) % 4]
    964 					   << "), int(" << values[(drawBufferNdx + 3) % 4] << "));\n";
    965 				break;
    966 
    967 			default:
    968 				DE_ASSERT(DE_FALSE);
    969 		};
    970 	}
    971 
    972 	stream << "}";
    973 
    974 	map<string, string> args;
    975 	args["GLSL_VERSION_DECL"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    976 	args["GLSL_EXTENSION"] = isES32 ? "\n" : "#extension GL_KHR_blend_equation_advanced : require\n";
    977 
    978 	return glu::FragmentSource(tcu::StringTemplate(stream.str()).specialize(args));
    979 }
    980 
    981 glu::ProgramSources genShaderSources (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const vector<DrawBufferInfo>& drawBuffers, glu::RenderContext& renderContext)
    982 {
    983 	return glu::ProgramSources() << genVertexSource(renderContext) << genFragmentSource(preCommonBlendState, postCommonBlendState, drawBuffers, renderContext);
    984 }
    985 
    986 void renderGLQuad (glu::RenderContext&			renderContext,
    987 				   const glu::ShaderProgram&	program)
    988 {
    989 	const glu::VertexArrayBinding vertexArrays[] =
    990 	{
    991 		glu::VertexArrayBinding(glu::BindingPoint(0), glu::VertexArrayPointer(glu::VTX_COMP_FLOAT, glu::VTX_COMP_CONVERT_NONE, 2, 6, 0, s_quadCoords))
    992 	};
    993 
    994 	glu::draw(renderContext, program.getProgram(), 1, vertexArrays, glu::pr::Triangles(6));
    995 }
    996 
    997 void renderQuad (TestLog&						log,
    998 				 glu::RenderContext&			renderContext,
    999 				 const BlendState&				preCommonBlendState,
   1000 				 const BlendState&				postCommonBlendState,
   1001 				 const vector<DrawBufferInfo>&	drawBuffers,
   1002 				 const glu::Framebuffer&		framebuffer,
   1003 				 vector<TextureLevel>&			refRenderbuffers)
   1004 {
   1005 	const glw::Functions&		gl						= renderContext.getFunctions();
   1006 	const glu::ShaderProgram	program					(gl, genShaderSources(preCommonBlendState, postCommonBlendState, drawBuffers, renderContext));
   1007 	const IVec2					size					= drawBuffers[0].getSize();
   1008 	const bool					requiresBlendBarriers	= requiresAdvancedBlendEq(preCommonBlendState, postCommonBlendState, drawBuffers);
   1009 
   1010 	vector<deUint32> bufs;
   1011 
   1012 	bufs.resize(drawBuffers.size());
   1013 
   1014 	for (int bufNdx = 0; bufNdx < (int)bufs.size(); bufNdx++)
   1015 		bufs[bufNdx] = (drawBuffers[bufNdx].getRender() ? GL_COLOR_ATTACHMENT0 + bufNdx : GL_NONE);
   1016 
   1017 	log << program;
   1018 
   1019 	gl.viewport(0, 0, size.x(), size.y());
   1020 	gl.useProgram(program.getProgram());
   1021 	gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
   1022 
   1023 	setCommonBlendState(gl, preCommonBlendState);
   1024 
   1025 	for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
   1026 		setIndexedBlendState(gl, drawBuffers[renderbufferNdx].getBlendState(), renderbufferNdx);
   1027 
   1028 	setCommonBlendState(gl, postCommonBlendState);
   1029 
   1030 	gl.drawBuffers((glw::GLsizei)bufs.size(), &(bufs[0]));
   1031 
   1032 	if (requiresBlendBarriers)
   1033 		gl.blendBarrier();
   1034 
   1035 	renderGLQuad(renderContext, program);
   1036 
   1037 	if (requiresBlendBarriers)
   1038 		gl.blendBarrier();
   1039 
   1040 	gl.drawBuffers(0, 0);
   1041 	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
   1042 	gl.useProgram(0);
   1043 
   1044 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render");
   1045 
   1046 	renderRefQuad(preCommonBlendState, postCommonBlendState, drawBuffers, refRenderbuffers);
   1047 }
   1048 
   1049 void logBlendState (TestLog&			log,
   1050 					const BlendState&	blend)
   1051 {
   1052 	if (blend.enableBlend)
   1053 	{
   1054 		if (*blend.enableBlend)
   1055 			log << TestLog::Message << "Enable blending." << TestLog::EndMessage;
   1056 		else
   1057 			log << TestLog::Message << "Disable blending." << TestLog::EndMessage;
   1058 	}
   1059 
   1060 	if (blend.colorMask)
   1061 	{
   1062 		const BVec4 mask = *blend.colorMask;
   1063 
   1064 		log << TestLog::Message << "Set color mask: " << mask << "." << TestLog::EndMessage;
   1065 	}
   1066 
   1067 	if (blend.blendEq)
   1068 	{
   1069 		const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
   1070 
   1071 		if (blendEq.is<BlendEq>())
   1072 			log << TestLog::Message << "Set blend equation: " << glu::getBlendEquationStr(blendEq.get<BlendEq>()) << "." << TestLog::EndMessage;
   1073 		else if (blendEq.is<SeparateBlendEq>())
   1074 			log << TestLog::Message << "Set blend equation rgb: " << glu::getBlendEquationStr(blendEq.get<SeparateBlendEq>().rgb) << ", alpha: " << glu::getBlendEquationStr(blendEq.get<SeparateBlendEq>().alpha) << "." << TestLog::EndMessage;
   1075 		else
   1076 			DE_ASSERT(false);
   1077 	}
   1078 
   1079 	if (blend.blendFunc)
   1080 	{
   1081 		const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
   1082 
   1083 		if (blendFunc.is<BlendFunc>())
   1084 			log << TestLog::Message << "Set blend function source: " << glu::getBlendFactorStr(blendFunc.get<BlendFunc>().src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<BlendFunc>().dst) << "." << TestLog::EndMessage;
   1085 		else if (blendFunc.is<SeparateBlendFunc>())
   1086 		{
   1087 			log << TestLog::Message << "Set blend function rgb source: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().rgb.src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().rgb.dst) << "." << TestLog::EndMessage;
   1088 			log << TestLog::Message << "Set blend function alpha source: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().alpha.src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().alpha.dst) << "." << TestLog::EndMessage;
   1089 		}
   1090 		else
   1091 			DE_ASSERT(false);
   1092 	}
   1093 }
   1094 
   1095 void logTestCaseInfo (TestLog&						log,
   1096 					  const BlendState&				preCommonBlendState,
   1097 					  const BlendState&				postCommonBlendState,
   1098 					  const vector<DrawBufferInfo>&	drawBuffers)
   1099 {
   1100 	{
   1101 		tcu::ScopedLogSection drawBuffersSection(log, "DrawBuffers", "Draw buffers");
   1102 
   1103 		for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
   1104 		{
   1105 			const tcu::ScopedLogSection	drawBufferSection	(log, "DrawBuffer" + de::toString(drawBufferNdx), "Draw Buffer " + de::toString(drawBufferNdx));
   1106 			const DrawBufferInfo&		drawBuffer			= drawBuffers[drawBufferNdx];
   1107 
   1108 			log << TestLog::Message << "Format: " << drawBuffer.getFormat() << TestLog::EndMessage;
   1109 			log << TestLog::Message << "Size: " << drawBuffer.getSize() << TestLog::EndMessage;
   1110 			log << TestLog::Message << "Render: " << (drawBuffer.getRender() ? "true" : "false") << TestLog::EndMessage;
   1111 		}
   1112 	}
   1113 
   1114 	if (!preCommonBlendState.isEmpty())
   1115 	{
   1116 		tcu::ScopedLogSection s(log, "PreCommonState", "First set common blend state");
   1117 		logBlendState(log, preCommonBlendState);
   1118 	}
   1119 
   1120 	for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
   1121 	{
   1122 		if (!drawBuffers[drawBufferNdx].getBlendState().isEmpty())
   1123 		{
   1124 			const tcu::ScopedLogSection s(log, "DrawBufferState" + de::toString(drawBufferNdx), "Set DrawBuffer " + de::toString(drawBufferNdx) + " state to");
   1125 
   1126 			logBlendState(log, drawBuffers[drawBufferNdx].getBlendState());
   1127 		}
   1128 	}
   1129 
   1130 	if (!postCommonBlendState.isEmpty())
   1131 	{
   1132 		tcu::ScopedLogSection s(log, "PostCommonState", "After set common blend state");
   1133 		logBlendState(log, postCommonBlendState);
   1134 	}
   1135 }
   1136 
   1137 void runTest (TestLog&						log,
   1138 			  tcu::ResultCollector&			results,
   1139 			  glu::RenderContext&			renderContext,
   1140 
   1141 			  const BlendState&				preCommonBlendState,
   1142 			  const BlendState&				postCommonBlendState,
   1143 			  const vector<DrawBufferInfo>&	drawBuffers)
   1144 {
   1145 	const glw::Functions&	gl					= renderContext.getFunctions();
   1146 	glu::RenderbufferVector	renderbuffers		(gl, drawBuffers.size());
   1147 	glu::Framebuffer		framebuffer			(gl);
   1148 	vector<TextureLevel>	refRenderbuffers	(drawBuffers.size());
   1149 
   1150 	logTestCaseInfo(log, preCommonBlendState, postCommonBlendState, drawBuffers);
   1151 
   1152 	genRenderbuffers(gl, drawBuffers, framebuffer, renderbuffers, refRenderbuffers);
   1153 
   1154 	renderQuad(log, renderContext, preCommonBlendState, postCommonBlendState, drawBuffers, framebuffer, refRenderbuffers);
   1155 
   1156 	verifyRenderbuffers(log, results, renderContext, renderbuffers, framebuffer, refRenderbuffers);
   1157 }
   1158 
   1159 class DrawBuffersIndexedTest : public TestCase
   1160 {
   1161 public:
   1162 					DrawBuffersIndexedTest (Context&						context,
   1163 											const BlendState&				preCommonBlendState,
   1164 											const BlendState&				postCommonBlendState,
   1165 											const vector<DrawBufferInfo>&	drawBuffers,
   1166 											const string&					name,
   1167 											const string&					description);
   1168 
   1169 	void			init					(void);
   1170 	IterateResult	iterate					(void);
   1171 
   1172 private:
   1173 	const BlendState				m_preCommonBlendState;
   1174 	const BlendState				m_postCommonBlendState;
   1175 	const vector<DrawBufferInfo>	m_drawBuffers;
   1176 };
   1177 
   1178 DrawBuffersIndexedTest::DrawBuffersIndexedTest (Context&						context,
   1179 												const BlendState&				preCommonBlendState,
   1180 												const BlendState&				postCommonBlendState,
   1181 												const vector<DrawBufferInfo>&	drawBuffers,
   1182 												const string&					name,
   1183 												const string&					description)
   1184 	: TestCase					(context, name.c_str(), description.c_str())
   1185 	, m_preCommonBlendState		(preCommonBlendState)
   1186 	, m_postCommonBlendState	(postCommonBlendState)
   1187 	, m_drawBuffers				(drawBuffers)
   1188 {
   1189 }
   1190 
   1191 void DrawBuffersIndexedTest::init (void)
   1192 {
   1193 	const bool isES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
   1194 
   1195 	if (!isES32)
   1196 	{
   1197 		if (requiresAdvancedBlendEq(m_preCommonBlendState, m_postCommonBlendState, m_drawBuffers) && !m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
   1198 			TCU_THROW(NotSupportedError, "Extension GL_KHR_blend_equation_advanced not supported");
   1199 
   1200 		if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
   1201 			TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
   1202 	}
   1203 }
   1204 
   1205 TestCase::IterateResult DrawBuffersIndexedTest::iterate (void)
   1206 {
   1207 	TestLog&				log		= m_testCtx.getLog();
   1208 	tcu::ResultCollector	results	(log);
   1209 
   1210 	runTest(log, results, m_context.getRenderContext(), m_preCommonBlendState, m_postCommonBlendState, m_drawBuffers);
   1211 
   1212 	results.setTestContextResult(m_testCtx);
   1213 
   1214 	return STOP;
   1215 }
   1216 
   1217 BlendEq getRandomBlendEq (de::Random& rng)
   1218 {
   1219 	const BlendEq eqs[] =
   1220 	{
   1221 		GL_FUNC_ADD,
   1222 		GL_FUNC_SUBTRACT,
   1223 		GL_FUNC_REVERSE_SUBTRACT,
   1224 		GL_MIN,
   1225 		GL_MAX
   1226 	};
   1227 
   1228 	return de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(eqs)>(eqs, rng.getUint32() % DE_LENGTH_OF_ARRAY(eqs));
   1229 }
   1230 
   1231 BlendFunc getRandomBlendFunc (de::Random& rng)
   1232 {
   1233 	const deUint32 funcs[] =
   1234 	{
   1235 		GL_ZERO,
   1236 		GL_ONE,
   1237 		GL_SRC_COLOR,
   1238 		GL_ONE_MINUS_SRC_COLOR,
   1239 		GL_DST_COLOR,
   1240 		GL_ONE_MINUS_DST_COLOR,
   1241 		GL_SRC_ALPHA,
   1242 		GL_ONE_MINUS_SRC_ALPHA,
   1243 		GL_DST_ALPHA,
   1244 		GL_ONE_MINUS_DST_ALPHA,
   1245 		GL_CONSTANT_COLOR,
   1246 		GL_ONE_MINUS_CONSTANT_COLOR,
   1247 		GL_CONSTANT_ALPHA,
   1248 		GL_ONE_MINUS_CONSTANT_ALPHA,
   1249 		GL_SRC_ALPHA_SATURATE
   1250 	};
   1251 
   1252 	const deUint32 src = de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(funcs)>(funcs, rng.getUint32() % DE_LENGTH_OF_ARRAY(funcs));
   1253 	const deUint32 dst = de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(funcs)>(funcs, rng.getUint32() % DE_LENGTH_OF_ARRAY(funcs));
   1254 
   1255 	return BlendFunc(src, dst);
   1256 }
   1257 
   1258 void genRandomBlendState (de::Random& rng, BlendState& blendState)
   1259 {
   1260 	if (rng.getBool())
   1261 		blendState.enableBlend = rng.getBool();
   1262 
   1263 	if (rng.getBool())
   1264 	{
   1265 		if (rng.getBool())
   1266 			blendState.blendEq = getRandomBlendEq(rng);
   1267 		else
   1268 		{
   1269 			const BlendEq	rgb		= getRandomBlendEq(rng);
   1270 			const BlendEq	alpha	= getRandomBlendEq(rng);
   1271 
   1272 			blendState.blendEq		= SeparateBlendEq(rgb, alpha);
   1273 		}
   1274 	}
   1275 
   1276 	if (rng.getBool())
   1277 	{
   1278 		if (rng.getBool())
   1279 			blendState.blendFunc = getRandomBlendFunc(rng);
   1280 		else
   1281 		{
   1282 			const BlendFunc	rgb		= getRandomBlendFunc(rng);
   1283 			const BlendFunc	alpha	= getRandomBlendFunc(rng);
   1284 
   1285 			blendState.blendFunc	= SeparateBlendFunc(rgb, alpha);
   1286 		}
   1287 	}
   1288 
   1289 	if (rng.getBool())
   1290 	{
   1291 		const bool red		= rng.getBool();
   1292 		const bool green	= rng.getBool();
   1293 		const bool blue		= rng.getBool();
   1294 		const bool alpha	= rng.getBool();
   1295 
   1296 		blendState.colorMask = BVec4(red, blue, green, alpha);
   1297 	}
   1298 }
   1299 
   1300 TextureFormat getRandomFormat (de::Random& rng, Context& context)
   1301 {
   1302 	const bool isES32 = glu::contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2));
   1303 
   1304 	const deUint32 glFormats[] =
   1305 	{
   1306 		GL_R8,
   1307 		GL_RG8,
   1308 		GL_RGB8,
   1309 		GL_RGB565,
   1310 		GL_RGBA4,
   1311 		GL_RGB5_A1,
   1312 		GL_RGBA8,
   1313 		GL_RGB10_A2,
   1314 		GL_RGB10_A2UI,
   1315 		GL_R8I,
   1316 		GL_R8UI,
   1317 		GL_R16I,
   1318 		GL_R16UI,
   1319 		GL_R32I,
   1320 		GL_R32UI,
   1321 		GL_RG8I,
   1322 		GL_RG8UI,
   1323 		GL_RG16I,
   1324 		GL_RG16UI,
   1325 		GL_RG32I,
   1326 		GL_RG32UI,
   1327 		GL_RGBA8I,
   1328 		GL_RGBA8UI,
   1329 		GL_RGBA16I,
   1330 		GL_RGBA16UI,
   1331 		GL_RGBA32I,
   1332 		GL_RGBA32UI,
   1333 		GL_RGBA16F,
   1334 		GL_R32F,
   1335 		GL_RG32F,
   1336 		GL_RGBA32F,
   1337 		GL_R11F_G11F_B10F
   1338 	};
   1339 
   1340 	if (isES32)
   1341 		return glu::mapGLInternalFormat(de::getArrayElement(glFormats, rng.getUint32() % DE_LENGTH_OF_ARRAY(glFormats)));
   1342 	else
   1343 	{
   1344 		DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(glFormats) == 32);
   1345 		return glu::mapGLInternalFormat(de::getArrayElement(glFormats, rng.getUint32() % (DE_LENGTH_OF_ARRAY(glFormats) - 5)));
   1346 	}
   1347 }
   1348 
   1349 void genRandomTest (de::Random& rng, BlendState& preCommon, BlendState& postCommon, vector<DrawBufferInfo>& drawBuffers, int maxDrawBufferCount, Context& context)
   1350 {
   1351 	genRandomBlendState(rng, preCommon);
   1352 	genRandomBlendState(rng, postCommon);
   1353 
   1354 	for (int drawBufferNdx = 0; drawBufferNdx < maxDrawBufferCount; drawBufferNdx++)
   1355 	{
   1356 		const bool			render		= rng.getFloat() > 0.1f;
   1357 		const IVec2			size		(64, 64);
   1358 		const TextureFormat	format		(getRandomFormat(rng, context));
   1359 		BlendState			blendState;
   1360 
   1361 		genRandomBlendState(rng, blendState);
   1362 
   1363 		// 32bit float formats don't support blending in GLES32
   1364 		if (format.type == tcu::TextureFormat::FLOAT)
   1365 		{
   1366 			// If format is 32bit float post common can't enable blending
   1367 			if (postCommon.enableBlend && *postCommon.enableBlend)
   1368 			{
   1369 				// Either don't set enable blend or disable blending
   1370 				if (rng.getBool())
   1371 					postCommon.enableBlend = tcu::nothing<bool>();
   1372 				else
   1373 					postCommon.enableBlend = tcu::just(false);
   1374 			}
   1375 
   1376 			// If post common doesn't disable blending, per attachment state or
   1377 			// pre common must.
   1378 			if (!postCommon.enableBlend)
   1379 			{
   1380 				// If pre common enables blend per attachment must disable it
   1381 				// If per attachment state changes blend state it must disable it
   1382 				if ((preCommon.enableBlend && *preCommon.enableBlend)
   1383 					|| blendState.enableBlend)
   1384 					blendState.enableBlend = tcu::just(false);
   1385 			}
   1386 		}
   1387 
   1388 		drawBuffers.push_back(DrawBufferInfo(render, size, blendState, format));
   1389 	}
   1390 }
   1391 
   1392 class MaxDrawBuffersIndexedTest : public TestCase
   1393 {
   1394 public:
   1395 					MaxDrawBuffersIndexedTest	(Context& contet, int seed);
   1396 
   1397 	void			init						(void);
   1398 	IterateResult	iterate						(void);
   1399 
   1400 private:
   1401 	const int		m_seed;
   1402 };
   1403 
   1404 MaxDrawBuffersIndexedTest::MaxDrawBuffersIndexedTest (Context& context, int seed)
   1405 	: TestCase	(context, de::toString(seed).c_str(), de::toString(seed).c_str())
   1406 	, m_seed	(deInt32Hash(seed) ^ 1558001307u)
   1407 {
   1408 }
   1409 
   1410 void MaxDrawBuffersIndexedTest::init (void)
   1411 {
   1412 	const bool isES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
   1413 
   1414 	if (!isES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
   1415 		TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
   1416 }
   1417 
   1418 TestCase::IterateResult MaxDrawBuffersIndexedTest::iterate (void)
   1419 {
   1420 	TestLog&				log						= m_testCtx.getLog();
   1421 	tcu::ResultCollector	results					(log);
   1422 	de::Random				rng						(m_seed);
   1423 	BlendState				preCommonBlendState;
   1424 	BlendState				postCommonBlendState;
   1425 	vector<DrawBufferInfo>	drawBuffers;
   1426 
   1427 	genRandomTest(rng, preCommonBlendState, postCommonBlendState, drawBuffers, 4, m_context);
   1428 
   1429 	runTest(log, results, m_context.getRenderContext(), preCommonBlendState, postCommonBlendState, drawBuffers);
   1430 
   1431 	results.setTestContextResult(m_testCtx);
   1432 
   1433 	return STOP;
   1434 }
   1435 
   1436 class ImplMaxDrawBuffersIndexedTest : public TestCase
   1437 {
   1438 public:
   1439 					ImplMaxDrawBuffersIndexedTest	(Context& contet, int seed);
   1440 
   1441 	void			init							(void);
   1442 	IterateResult	iterate							(void);
   1443 
   1444 private:
   1445 	const int		m_seed;
   1446 };
   1447 
   1448 ImplMaxDrawBuffersIndexedTest::ImplMaxDrawBuffersIndexedTest (Context& context, int seed)
   1449 	: TestCase	(context, de::toString(seed).c_str(), de::toString(seed).c_str())
   1450 	, m_seed	(deInt32Hash(seed) ^ 2686315738u)
   1451 {
   1452 }
   1453 
   1454 void ImplMaxDrawBuffersIndexedTest::init (void)
   1455 {
   1456 	const bool isES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
   1457 
   1458 	if (!isES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
   1459 		TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
   1460 }
   1461 
   1462 TestCase::IterateResult ImplMaxDrawBuffersIndexedTest::iterate (void)
   1463 {
   1464 	TestLog&				log						= m_testCtx.getLog();
   1465 	tcu::ResultCollector	results					(log);
   1466 	const glw::Functions&	gl						= m_context.getRenderContext().getFunctions();
   1467 	de::Random				rng						(m_seed);
   1468 	deInt32					maxDrawBuffers			= 0;
   1469 	BlendState				preCommonBlendState;
   1470 	BlendState				postCommonBlendState;
   1471 	vector<DrawBufferInfo>	drawBuffers;
   1472 
   1473 	gl.getIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
   1474 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_DRAW_BUFFERS) failed");
   1475 
   1476 	TCU_CHECK(maxDrawBuffers > 0);
   1477 
   1478 	genRandomTest(rng, preCommonBlendState, postCommonBlendState, drawBuffers, maxDrawBuffers, m_context);
   1479 
   1480 	runTest(log, results, m_context.getRenderContext(), preCommonBlendState, postCommonBlendState, drawBuffers);
   1481 
   1482 	results.setTestContextResult(m_testCtx);
   1483 
   1484 	return STOP;
   1485 }
   1486 
   1487 enum PrePost
   1488 {
   1489 	PRE,
   1490 	POST
   1491 };
   1492 
   1493 TestCase* createDiffTest (Context& context, PrePost prepost, const char* name, const BlendState& commonState, const BlendState& drawBufferState)
   1494 {
   1495 	const BlendState emptyState = BlendState(tcu::nothing<bool>(), tcu::nothing<Either<BlendEq, SeparateBlendEq> >(), tcu::nothing<Either<BlendFunc, SeparateBlendFunc> >(), tcu::nothing<BVec4>());
   1496 
   1497 	if (prepost == PRE)
   1498 	{
   1499 		const BlendState		preState	= BlendState((commonState.enableBlend ? commonState.enableBlend : just(true)),
   1500 														 commonState.blendEq,
   1501 														 (commonState.blendFunc ? commonState.blendFunc : just(Either<BlendFunc, SeparateBlendFunc>(BlendFunc(GL_ONE, GL_ONE)))),
   1502 														 tcu::nothing<BVec4>());
   1503 		vector<DrawBufferInfo>	drawBuffers;
   1504 
   1505 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), emptyState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1506 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1507 
   1508 		return new DrawBuffersIndexedTest(context, preState, emptyState, drawBuffers, name, name);
   1509 	}
   1510 	else if (prepost == POST)
   1511 	{
   1512 		const BlendState		preState	= BlendState(just(true),
   1513 														 tcu::nothing<Either<BlendEq, SeparateBlendEq> >(),
   1514 														 Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_ONE, GL_ONE)),
   1515 														 tcu::nothing<BVec4>());
   1516 		vector<DrawBufferInfo>	drawBuffers;
   1517 
   1518 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), emptyState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1519 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1520 
   1521 		return new DrawBuffersIndexedTest(context, preState, commonState, drawBuffers, name, name);
   1522 	}
   1523 	else
   1524 	{
   1525 		DE_ASSERT(false);
   1526 		return DE_NULL;
   1527 	}
   1528 }
   1529 
   1530 TestCase* createAdvancedEqDiffTest (Context& context, PrePost prepost, const char* name, const BlendState& commonState, const BlendState& drawBufferState)
   1531 {
   1532 	const BlendState emptyState = BlendState(tcu::nothing<bool>(), tcu::nothing<Either<BlendEq, SeparateBlendEq> >(), tcu::nothing<Either<BlendFunc, SeparateBlendFunc> >(), tcu::nothing<BVec4>());
   1533 
   1534 	if (prepost == PRE)
   1535 	{
   1536 		const BlendState		preState	= BlendState((commonState.enableBlend ? commonState.enableBlend : just(true)),
   1537 														 commonState.blendEq,
   1538 														 (commonState.blendFunc ? commonState.blendFunc : just(Either<BlendFunc, SeparateBlendFunc>(BlendFunc(GL_ONE, GL_ONE)))),
   1539 														 tcu::nothing<BVec4>());
   1540 		vector<DrawBufferInfo>	drawBuffers;
   1541 
   1542 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1543 
   1544 		return new DrawBuffersIndexedTest(context, preState, emptyState, drawBuffers, name, name);
   1545 	}
   1546 	else if (prepost == POST)
   1547 	{
   1548 		const BlendState		preState	= BlendState(just(true),
   1549 														 tcu::nothing<Either<BlendEq, SeparateBlendEq> >(),
   1550 														 Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_ONE, GL_ONE)),
   1551 														 tcu::nothing<BVec4>());
   1552 		vector<DrawBufferInfo>	drawBuffers;
   1553 
   1554 		drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
   1555 
   1556 		return new DrawBuffersIndexedTest(context, preState, commonState, drawBuffers, name, name);
   1557 	}
   1558 	else
   1559 	{
   1560 		DE_ASSERT(false);
   1561 		return DE_NULL;
   1562 	}
   1563 }
   1564 
   1565 void addDrawBufferCommonTests (TestCaseGroup* root, PrePost prepost)
   1566 {
   1567 	const BlendState		emptyState	= BlendState(Maybe<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1568 
   1569 	{
   1570 		const BlendState	disableState	= BlendState(just(false), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1571 		const BlendState	enableState		= BlendState(just(true), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1572 
   1573 		root->addChild(createDiffTest(root->getContext(), prepost, "common_enable_buffer_enable",	enableState,	enableState));
   1574 		root->addChild(createDiffTest(root->getContext(), prepost, "common_disable_buffer_disable",	disableState,	disableState));
   1575 		root->addChild(createDiffTest(root->getContext(), prepost, "common_disable_buffer_enable",	disableState,	enableState));
   1576 		root->addChild(createDiffTest(root->getContext(), prepost, "common_enable_buffer_disable",	enableState,	disableState));
   1577 	}
   1578 
   1579 	{
   1580 		const BlendState	eqStateA			= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_FUNC_ADD), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1581 		const BlendState	eqStateB			= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_FUNC_SUBTRACT), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1582 
   1583 		const BlendState	separateEqStateA	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(SeparateBlendEq(GL_FUNC_ADD, GL_FUNC_SUBTRACT)), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1584 		const BlendState	separateEqStateB	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(SeparateBlendEq(GL_FUNC_SUBTRACT, GL_FUNC_ADD)), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1585 
   1586 		const BlendState	advancedEqStateA	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_DIFFERENCE), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1587 		const BlendState	advancedEqStateB	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_SCREEN), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1588 
   1589 		root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_blend_eq", eqStateA, eqStateB));
   1590 		root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_separate_blend_eq", eqStateA, separateEqStateB));
   1591 		root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_advanced_blend_eq", eqStateA, advancedEqStateB));
   1592 
   1593 		root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_blend_eq", separateEqStateA, eqStateB));
   1594 		root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_separate_blend_eq", separateEqStateA, separateEqStateB));
   1595 		root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_advanced_blend_eq", separateEqStateA, advancedEqStateB));
   1596 
   1597 		root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_blend_eq", advancedEqStateA, eqStateB));
   1598 		root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_separate_blend_eq", advancedEqStateA, separateEqStateB));
   1599 		root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_advanced_blend_eq", advancedEqStateA, advancedEqStateB));
   1600 	}
   1601 
   1602 	{
   1603 		const BlendState	funcStateA			= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA)), Maybe<BVec4>());
   1604 		const BlendState	funcStateB			= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_DST_ALPHA, GL_SRC_ALPHA)), Maybe<BVec4>());
   1605 		const BlendState	separateFuncStateA	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(SeparateBlendFunc(BlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA), BlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA))), Maybe<BVec4>());
   1606 		const BlendState	separateFuncStateB	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(SeparateBlendFunc(BlendFunc(GL_DST_ALPHA, GL_SRC_ALPHA), BlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA))), Maybe<BVec4>());
   1607 
   1608 		root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_func_buffer_blend_func",					funcStateA,			funcStateB));
   1609 		root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_func_buffer_separate_blend_func",			funcStateA,			separateFuncStateB));
   1610 		root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_func_buffer_blend_func",			separateFuncStateA,	funcStateB));
   1611 		root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_func_buffer_separate_blend_func",	separateFuncStateA,	separateFuncStateB));
   1612 	}
   1613 
   1614 	{
   1615 		const BlendState	commonColorMaskState	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>(BVec4(true, false, true, false)));
   1616 		const BlendState	bufferColorMaskState	= BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>(BVec4(false, true, false, true)));
   1617 
   1618 		root->addChild(createDiffTest(root->getContext(), prepost, "common_color_mask_buffer_color_mask", commonColorMaskState, bufferColorMaskState));
   1619 	}
   1620 }
   1621 
   1622 void addRandomMaxTest (TestCaseGroup* root)
   1623 {
   1624 	for (int i = 0; i < 20; i++)
   1625 		root->addChild(new MaxDrawBuffersIndexedTest(root->getContext(), i));
   1626 }
   1627 
   1628 void addRandomImplMaxTest (TestCaseGroup* root)
   1629 {
   1630 	for (int i = 0; i < 20; i++)
   1631 		root->addChild(new ImplMaxDrawBuffersIndexedTest(root->getContext(), i));
   1632 }
   1633 
   1634 } // anonymous
   1635 
   1636 TestCaseGroup* createDrawBuffersIndexedTests (Context& context)
   1637 {
   1638 	const BlendState		emptyState		= BlendState(Maybe<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
   1639 	TestCaseGroup* const	group			= new TestCaseGroup(context, "draw_buffers_indexed", "Test for indexed draw buffers. GL_EXT_draw_buffers_indexed.");
   1640 
   1641 	TestCaseGroup* const	preGroup		= new TestCaseGroup(context, "overwrite_common", "Set common state and overwrite it with draw buffer blend state.");
   1642 	TestCaseGroup* const	postGroup		= new TestCaseGroup(context, "overwrite_indexed", "Set indexed blend state and overwrite it with common state.");
   1643 	TestCaseGroup* const	randomGroup		= new TestCaseGroup(context, "random", "Random indexed blend state tests.");
   1644 	TestCaseGroup* const	maxGroup		= new TestCaseGroup(context, "max_required_draw_buffers", "Random tests using minimum maximum number of draw buffers.");
   1645 	TestCaseGroup* const	maxImplGroup	= new TestCaseGroup(context, "max_implementation_draw_buffers", "Random tests using maximum number of draw buffers reported by implementation.");
   1646 
   1647 	group->addChild(preGroup);
   1648 	group->addChild(postGroup);
   1649 	group->addChild(randomGroup);
   1650 
   1651 	randomGroup->addChild(maxGroup);
   1652 	randomGroup->addChild(maxImplGroup);
   1653 
   1654 	addDrawBufferCommonTests(preGroup, PRE);
   1655 	addDrawBufferCommonTests(postGroup, POST);
   1656 	addRandomMaxTest(maxGroup);
   1657 	addRandomImplMaxTest(maxImplGroup);
   1658 
   1659 	return group;
   1660 }
   1661 
   1662 } // Functional
   1663 } // gles31
   1664 } // deqp
   1665