1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 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 Blend tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "es2fBlendTests.hpp"
25#include "glsFragmentOpUtil.hpp"
26#include "gluPixelTransfer.hpp"
27#include "gluStrUtil.hpp"
28#include "tcuSurface.hpp"
29#include "tcuImageCompare.hpp"
30#include "tcuRenderTarget.hpp"
31#include "tcuTestLog.hpp"
32#include "tcuTextureUtil.hpp"
33#include "deRandom.hpp"
34#include "rrFragmentOperations.hpp"
35#include "sglrReferenceUtils.hpp"
36
37#include "glw.h"
38
39#include <string>
40#include <vector>
41
42namespace deqp
43{
44
45using gls::FragmentOpUtil::Quad;
46using gls::FragmentOpUtil::IntegerQuad;
47using gls::FragmentOpUtil::QuadRenderer;
48using gls::FragmentOpUtil::ReferenceQuadRenderer;
49using glu::getBlendEquationName;
50using glu::getBlendFactorName;
51using tcu::Vec4;
52using tcu::UVec4;
53using tcu::TestLog;
54using tcu::Surface;
55using tcu::TextureFormat;
56using tcu::TextureLevel;
57using std::string;
58using std::vector;
59
60namespace gles2
61{
62namespace Functional
63{
64
65static const int MAX_VIEWPORT_WIDTH		= 64;
66static const int MAX_VIEWPORT_HEIGHT	= 64;
67
68struct BlendParams
69{
70	GLenum	equationRGB;
71	GLenum	srcFuncRGB;
72	GLenum	dstFuncRGB;
73	GLenum	equationAlpha;
74	GLenum	srcFuncAlpha;
75	GLenum	dstFuncAlpha;
76	Vec4	blendColor;
77
78	BlendParams (GLenum		equationRGB_,
79				 GLenum		srcFuncRGB_,
80				 GLenum		dstFuncRGB_,
81				 GLenum		equationAlpha_,
82				 GLenum		srcFuncAlpha_,
83				 GLenum		dstFuncAlpha_,
84				 Vec4		blendColor_)
85	: equationRGB	(equationRGB_)
86	, srcFuncRGB	(srcFuncRGB_)
87	, dstFuncRGB	(dstFuncRGB_)
88	, equationAlpha	(equationAlpha_)
89	, srcFuncAlpha	(srcFuncAlpha_)
90	, dstFuncAlpha	(dstFuncAlpha_)
91	, blendColor	(blendColor_)
92	{
93	}
94};
95
96class BlendCase : public TestCase
97{
98public:
99							BlendCase	(Context&						context,
100										 const char*					name,
101										 const char*					desc,
102										 const vector<BlendParams>&		paramSets);
103
104							~BlendCase	(void);
105
106	void					init		(void);
107	void					deinit		(void);
108
109	IterateResult			iterate		(void);
110
111private:
112							BlendCase	(const BlendCase& other);
113	BlendCase&				operator=	(const BlendCase& other);
114
115	vector<BlendParams>		m_paramSets;
116	int						m_curParamSetNdx;
117
118	QuadRenderer*			m_renderer;
119	ReferenceQuadRenderer*	m_referenceRenderer;
120	TextureLevel*			m_refColorBuffer;
121	Quad					m_firstQuad;
122	Quad					m_secondQuad;
123	IntegerQuad				m_firstQuadInt;
124	IntegerQuad				m_secondQuadInt;
125
126	int						m_viewportW;
127	int						m_viewportH;
128};
129
130BlendCase::BlendCase (Context&						context,
131					  const char*					name,
132					  const char*					desc,
133					  const vector<BlendParams>&	paramSets)
134	: TestCase				(context, name, desc)
135	, m_paramSets			(paramSets)
136	, m_curParamSetNdx		(0)
137	, m_renderer			(DE_NULL)
138	, m_referenceRenderer	(DE_NULL)
139	, m_refColorBuffer		(DE_NULL)
140	, m_viewportW			(0)
141	, m_viewportH			(0)
142{
143	DE_ASSERT(!m_paramSets.empty());
144	for (int i = 0; i < (int)m_paramSets.size(); i++)
145		DE_ASSERT(m_paramSets[i].dstFuncRGB != GL_SRC_ALPHA_SATURATE && m_paramSets[i].dstFuncAlpha != GL_SRC_ALPHA_SATURATE);
146}
147
148void BlendCase::init (void)
149{
150	bool useRGB = m_context.getRenderTarget().getPixelFormat().alphaBits == 0;
151
152	static const Vec4 baseGradientColors[4] =
153	{
154		Vec4(0.0f, 0.5f, 1.0f, 0.5f),
155		Vec4(0.5f, 0.0f, 0.5f, 1.0f),
156		Vec4(0.5f, 1.0f, 0.5f, 0.0f),
157		Vec4(1.0f, 0.5f, 0.0f, 0.5f)
158	};
159
160	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(m_firstQuad.color) == DE_LENGTH_OF_ARRAY(m_firstQuadInt.color));
161	for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_firstQuad.color); i++)
162	{
163		m_firstQuad.color[i]		= (baseGradientColors[i] - 0.5f) * 0.2f + 0.5f;
164		m_firstQuadInt.color[i]		= m_firstQuad.color[i];
165
166		m_secondQuad.color[i]		= (Vec4(1.0f) - baseGradientColors[i] - 0.5f) * 1.0f + 0.5f;
167		m_secondQuadInt.color[i]	= m_secondQuad.color[i];
168	}
169
170	m_viewportW = de::min<int>(m_context.getRenderTarget().getWidth(),	MAX_VIEWPORT_WIDTH);
171	m_viewportH = de::min<int>(m_context.getRenderTarget().getHeight(),	MAX_VIEWPORT_HEIGHT);
172
173	m_firstQuadInt.posA		= tcu::IVec2(0,					0);
174	m_secondQuadInt.posA	= tcu::IVec2(0,					0);
175	m_firstQuadInt.posB		= tcu::IVec2(m_viewportW-1,		m_viewportH-1);
176	m_secondQuadInt.posB	= tcu::IVec2(m_viewportW-1,		m_viewportH-1);
177
178	DE_ASSERT(!m_renderer);
179	DE_ASSERT(!m_referenceRenderer);
180	DE_ASSERT(!m_refColorBuffer);
181
182	m_renderer				= new QuadRenderer(m_context.getRenderContext(), glu::GLSL_VERSION_100_ES);
183	m_referenceRenderer		= new ReferenceQuadRenderer;
184	m_refColorBuffer		= new TextureLevel(TextureFormat(useRGB ? TextureFormat::RGB : TextureFormat::RGBA, TextureFormat::UNORM_INT8),
185											   m_viewportW, m_viewportH);
186
187	m_curParamSetNdx = 0;
188}
189
190BlendCase::~BlendCase (void)
191{
192	delete m_renderer;
193	delete m_referenceRenderer;
194	delete m_refColorBuffer;
195}
196
197void BlendCase::deinit (void)
198{
199	delete m_renderer;
200	delete m_referenceRenderer;
201	delete m_refColorBuffer;
202
203	m_renderer			= DE_NULL;
204	m_referenceRenderer	= DE_NULL;
205	m_refColorBuffer	= DE_NULL;
206}
207
208BlendCase::IterateResult BlendCase::iterate (void)
209{
210	de::Random						rnd				(deStringHash(getName()) ^ deInt32Hash(m_curParamSetNdx));
211	int								viewportX		= rnd.getInt(0, m_context.getRenderTarget().getWidth() - m_viewportW);
212	int								viewportY		= rnd.getInt(0, m_context.getRenderTarget().getHeight() - m_viewportH);
213	tcu::Surface					renderedImg		(m_viewportW, m_viewportH);
214	tcu::Surface					referenceImg	(m_viewportH, m_viewportH);
215	TestLog&						log				(m_testCtx.getLog());
216	const BlendParams&				paramSet		= m_paramSets[m_curParamSetNdx];
217	rr::FragmentOperationState		referenceState;
218
219	// Log the blend parameters.
220
221	log << TestLog::Message << "RGB equation = " << getBlendEquationName(paramSet.equationRGB) << TestLog::EndMessage;
222	log << TestLog::Message << "RGB src func = " << getBlendFactorName(paramSet.srcFuncRGB) << TestLog::EndMessage;
223	log << TestLog::Message << "RGB dst func = " << getBlendFactorName(paramSet.dstFuncRGB) << TestLog::EndMessage;
224	log << TestLog::Message << "Alpha equation = " << getBlendEquationName(paramSet.equationAlpha) << TestLog::EndMessage;
225	log << TestLog::Message << "Alpha src func = " << getBlendFactorName(paramSet.srcFuncAlpha) << TestLog::EndMessage;
226	log << TestLog::Message << "Alpha dst func = " << getBlendFactorName(paramSet.dstFuncAlpha) << TestLog::EndMessage;
227	log << TestLog::Message << "Blend color = (" << paramSet.blendColor.x() << ", " << paramSet.blendColor.y() << ", " << paramSet.blendColor.z() << ", " << paramSet.blendColor.w() << ")" << TestLog::EndMessage;
228
229	// Set GL state.
230
231	GLU_CHECK_CALL(glBlendEquationSeparate(paramSet.equationRGB, paramSet.equationAlpha));
232	GLU_CHECK_CALL(glBlendFuncSeparate(paramSet.srcFuncRGB, paramSet.dstFuncRGB, paramSet.srcFuncAlpha, paramSet.dstFuncAlpha));
233	GLU_CHECK_CALL(glBlendColor(paramSet.blendColor.x(), paramSet.blendColor.y(), paramSet.blendColor.z(), paramSet.blendColor.w()));
234
235	// Set reference state.
236
237	referenceState.blendRGBState.equation	= sglr::rr_util::mapGLBlendEquation(paramSet.equationRGB);
238	referenceState.blendRGBState.srcFunc	= sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncRGB);
239	referenceState.blendRGBState.dstFunc	= sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncRGB);
240	referenceState.blendAState.equation		= sglr::rr_util::mapGLBlendEquation(paramSet.equationAlpha);
241	referenceState.blendAState.srcFunc		= sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncAlpha);
242	referenceState.blendAState.dstFunc		= sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncAlpha);
243	referenceState.blendColor				= paramSet.blendColor;
244
245	// Render with GL.
246
247	glDisable(GL_BLEND);
248	glViewport(viewportX, viewportY, m_viewportW, m_viewportH);
249	m_renderer->render(m_firstQuad);
250	glEnable(GL_BLEND);
251	m_renderer->render(m_secondQuad);
252	glFlush();
253
254	// Render reference.
255
256	const tcu::PixelBufferAccess nullAccess = tcu::PixelBufferAccess();
257
258	referenceState.blendMode = rr::BLENDMODE_NONE;
259	m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_firstQuadInt, referenceState);
260	referenceState.blendMode = rr::BLENDMODE_STANDARD;
261	m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_secondQuadInt, referenceState);
262
263	// Expand reference color buffer to RGBA8
264	copy(referenceImg.getAccess(), m_refColorBuffer->getAccess());
265
266	// Read GL image.
267
268	glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, renderedImg.getAccess());
269
270	// Compare images.
271
272	UVec4 compareThreshold = m_context.getRenderTarget().getPixelFormat().getColorThreshold().toIVec().asUint()
273							 * UVec4(5) / UVec4(2) + UVec4(3); // \note Non-scientific ad hoc formula. Need big threshold when few color bits; blending brings extra inaccuracy.
274
275	bool comparePass = tcu::intThresholdCompare(m_testCtx.getLog(), "CompareResult", "Image Comparison Result", referenceImg.getAccess(), renderedImg.getAccess(), compareThreshold, tcu::COMPARE_LOG_RESULT);
276
277	// Fail now if images don't match.
278
279	if (!comparePass)
280	{
281		m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Image compare failed");
282		return STOP;
283	}
284
285	// Continue if param sets still remain in m_paramSets; otherwise stop.
286
287	m_curParamSetNdx++;
288
289	if (m_curParamSetNdx < (int)m_paramSets.size())
290		return CONTINUE;
291	else
292	{
293		m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Passed");
294		return STOP;
295	}
296}
297
298BlendTests::BlendTests (Context& context)
299	: TestCaseGroup(context, "blend", "Blend tests")
300{
301}
302
303BlendTests::~BlendTests (void)
304{
305}
306
307void BlendTests::init (void)
308{
309	struct EnumGL
310	{
311		GLenum			glValue;
312		const char*		nameStr;
313	};
314
315	static const EnumGL blendEquations[] =
316	{
317		{ GL_FUNC_ADD,					"add"					},
318		{ GL_FUNC_SUBTRACT,				"subtract"				},
319		{ GL_FUNC_REVERSE_SUBTRACT,		"reverse_subtract"		}
320	};
321
322	static const EnumGL blendFunctions[] =
323	{
324		{ GL_ZERO,							"zero"						},
325		{ GL_ONE,							"one"						},
326		{ GL_SRC_COLOR,						"src_color"					},
327		{ GL_ONE_MINUS_SRC_COLOR,			"one_minus_src_color"		},
328		{ GL_DST_COLOR,						"dst_color"					},
329		{ GL_ONE_MINUS_DST_COLOR,			"one_minus_dst_color"		},
330		{ GL_SRC_ALPHA,						"src_alpha"					},
331		{ GL_ONE_MINUS_SRC_ALPHA,			"one_minus_src_alpha"		},
332		{ GL_DST_ALPHA,						"dst_alpha"					},
333		{ GL_ONE_MINUS_DST_ALPHA,			"one_minus_dst_alpha"		},
334		{ GL_CONSTANT_COLOR,				"constant_color"			},
335		{ GL_ONE_MINUS_CONSTANT_COLOR,		"one_minus_constant_color"	},
336		{ GL_CONSTANT_ALPHA,				"constant_alpha"			},
337		{ GL_ONE_MINUS_CONSTANT_ALPHA,		"one_minus_constant_alpha"	},
338		{ GL_SRC_ALPHA_SATURATE,			"src_alpha_saturate"		}
339	};
340
341	const Vec4 defaultBlendColor(0.2f, 0.4f, 0.6f, 0.8f);
342
343	// Test all blend equation, src blend function, dst blend function combinations. RGB and alpha modes are the same.
344
345	{
346		TestCaseGroup* group = new TestCaseGroup(m_context, "equation_src_func_dst_func", "Combinations of Blend Equations and Functions");
347		addChild(group);
348
349		for (int equationNdx = 0;	equationNdx < DE_LENGTH_OF_ARRAY(blendEquations);	equationNdx++)
350		for (int srcFuncNdx = 0;	srcFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);	srcFuncNdx++)
351		for (int dstFuncNdx = 0;	dstFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);	dstFuncNdx++)
352		{
353			const EnumGL& eq	= blendEquations[equationNdx];
354			const EnumGL& src	= blendFunctions[srcFuncNdx];
355			const EnumGL& dst	= blendFunctions[dstFuncNdx];
356
357			if (dst.glValue == GL_SRC_ALPHA_SATURATE) // SRC_ALPHA_SATURATE is only valid for src func.
358				continue;
359
360			string name			= string("") + eq.nameStr + "_" + src.nameStr + "_" + dst.nameStr;
361			string description	= string("") +
362								  "Equations "		+ getBlendEquationName(eq.glValue) +
363								  ", src funcs "	+ getBlendFactorName(src.glValue) +
364								  ", dst funcs "	+ getBlendFactorName(dst.glValue);
365
366			vector<BlendParams> paramSets;
367			paramSets.push_back(BlendParams(eq.glValue, src.glValue, dst.glValue, eq.glValue, src.glValue, dst.glValue, defaultBlendColor));
368
369			group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
370		}
371	}
372
373	// Test all RGB src, alpha src and RGB dst, alpha dst combinations. Equations are ADD.
374	// \note For all RGB src, alpha src combinations, also test a couple of different RGBA dst functions, and vice versa.
375
376	{
377		TestCaseGroup* mainGroup = new TestCaseGroup(m_context, "rgb_func_alpha_func", "Combinations of RGB and Alpha Functions");
378		addChild(mainGroup);
379		TestCaseGroup* srcGroup = new TestCaseGroup(m_context, "src", "Source functions");
380		TestCaseGroup* dstGroup = new TestCaseGroup(m_context, "dst", "Destination functions");
381		mainGroup->addChild(srcGroup);
382		mainGroup->addChild(dstGroup);
383
384		for (int isDstI = 0;		isDstI <= 1;										isDstI++)
385		for (int rgbFuncNdx = 0;	rgbFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);	rgbFuncNdx++)
386		for (int alphaFuncNdx = 0;	alphaFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);	alphaFuncNdx++)
387		{
388			bool			isSrc			= isDstI == 0;
389			TestCaseGroup*	curGroup		= isSrc ? srcGroup : dstGroup;
390			const EnumGL&	funcRGB			= blendFunctions[rgbFuncNdx];
391			const EnumGL&	funcAlpha		= blendFunctions[alphaFuncNdx];
392			const char*		dstOrSrcStr		= isSrc ? "src" : "dst";
393
394			if (!isSrc && (funcRGB.glValue == GL_SRC_ALPHA_SATURATE || funcAlpha.glValue == GL_SRC_ALPHA_SATURATE)) // SRC_ALPHA_SATURATE is only valid for src func.
395				continue;
396
397			string name			= string("") + funcRGB.nameStr + "_" + funcAlpha.nameStr;
398			string description	= string("") +
399								  "RGB "		+ dstOrSrcStr + " func " + getBlendFactorName(funcRGB.glValue) +
400								  ", alpha "	+ dstOrSrcStr + " func " + getBlendFactorName(funcAlpha.glValue);
401
402			// First, make param sets as if this was a src case.
403
404			vector<BlendParams> paramSets;
405			paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ONE,			GL_FUNC_ADD, funcAlpha.glValue, GL_ONE,			defaultBlendColor));
406			paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ZERO,			GL_FUNC_ADD, funcAlpha.glValue, GL_ZERO,		defaultBlendColor));
407			paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_SRC_COLOR,		GL_FUNC_ADD, funcAlpha.glValue, GL_SRC_COLOR,	defaultBlendColor));
408			paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_DST_COLOR,		GL_FUNC_ADD, funcAlpha.glValue, GL_DST_COLOR,	defaultBlendColor));
409
410			// Swap src and dst params if this is a dst case.
411
412			if (!isSrc)
413			{
414				for (int i = 0; i < (int)paramSets.size(); i++)
415				{
416					std::swap(paramSets[i].srcFuncRGB,		paramSets[i].dstFuncRGB);
417					std::swap(paramSets[i].srcFuncAlpha,	paramSets[i].dstFuncAlpha);
418				}
419			}
420
421			curGroup->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
422		}
423	}
424
425	// Test all RGB and alpha equation combinations. Src and dst funcs are ONE for both.
426
427	{
428		TestCaseGroup* group = new TestCaseGroup(m_context, "rgb_equation_alpha_equation", "Combinations of RGB and Alpha Equation Combinations");
429		addChild(group);
430
431		for (int equationRGBNdx = 0;	equationRGBNdx < DE_LENGTH_OF_ARRAY(blendEquations);	equationRGBNdx++)
432		for (int equationAlphaNdx = 0;	equationAlphaNdx < DE_LENGTH_OF_ARRAY(blendEquations);	equationAlphaNdx++)
433		{
434			const EnumGL& eqRGB			= blendEquations[equationRGBNdx];
435			const EnumGL& eqAlpha		= blendEquations[equationAlphaNdx];
436
437			string name			= string("") + eqRGB.nameStr + "_" + eqAlpha.nameStr;
438			string description	= string("") +
439								  "RGB equation "		+ getBlendEquationName(eqRGB.glValue) +
440								  ", alpha equation "	+ getBlendEquationName(eqAlpha.glValue);
441
442			vector<BlendParams> paramSets;
443			paramSets.push_back(BlendParams(eqRGB.glValue, GL_ONE, GL_ONE, eqAlpha.glValue, GL_ONE, GL_ONE, defaultBlendColor));
444
445			group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
446		}
447	}
448}
449
450} // Functional
451} // gles2
452} // deqp
453