• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*-------------------------------------------------------------------------
2  * drawElements Quality Program OpenGL ES 3.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 Prerequisite tests.
22  *//*--------------------------------------------------------------------*/
23 
24 #include "es3fPrerequisiteTests.hpp"
25 #include "deRandom.h"
26 #include "tcuRGBA.hpp"
27 #include "tcuSurface.hpp"
28 #include "tcuTextureUtil.hpp"
29 #include "tcuTestLog.hpp"
30 #include "tcuRenderTarget.hpp"
31 #include "gluPixelTransfer.hpp"
32 #include "gluStateReset.hpp"
33 
34 #include "glw.h"
35 
36 using tcu::RGBA;
37 using tcu::Surface;
38 using tcu::TestLog;
39 
40 namespace deqp
41 {
42 namespace gles3
43 {
44 namespace Functional
45 {
46 
47 class StateResetCase : public TestCase
48 {
49 public:
50 										StateResetCase	(Context& context);
51 	virtual								~StateResetCase	(void);
52 	virtual TestCase::IterateResult		iterate			(void);
53 };
54 
StateResetCase(Context & context)55 StateResetCase::StateResetCase (Context& context)
56 	: TestCase(context, "state_reset", "State Reset Test")
57 {
58 }
59 
~StateResetCase(void)60 StateResetCase::~StateResetCase (void)
61 {
62 }
63 
iterate(void)64 TestCase::IterateResult StateResetCase::iterate (void)
65 {
66 	try
67 	{
68 		glu::resetState(m_context.getRenderContext(), m_context.getContextInfo());
69 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
70 	}
71 	catch (const tcu::TestError& e)
72 	{
73 		m_testCtx.getLog() << e;
74 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
75 	}
76 
77 	return TestCase::STOP;
78 }
79 
80 class ClearColorCase : public TestCase
81 {
82 public:
83 										ClearColorCase		(Context& context);
84 	virtual								~ClearColorCase		(void);
85 	virtual TestCase::IterateResult		iterate				(void);
86 
87 private:
88 	RGBA		m_clearColor;
89 	int			m_numIters;
90 	int			m_curIter;
91 };
92 
ClearColorCase(Context & context)93 ClearColorCase::ClearColorCase (Context& context)
94 	: TestCase		(context, "clear_color", "glClearColor test")
95 	, m_numIters	(10)
96 	, m_curIter		(0)
97 {
98 }
99 
~ClearColorCase(void)100 ClearColorCase::~ClearColorCase (void)
101 {
102 }
103 
iterate(void)104 TestCase::IterateResult ClearColorCase::iterate (void)
105 {
106 	int r = 0;
107 	int g = 0;
108 	int b = 0;
109 	int a = 255;
110 
111 	switch (m_curIter)
112 	{
113 		case 0:
114 			// Black, skip
115 			break;
116 		case 1:
117 			r = 255;
118 			g = 255;
119 			b = 255;
120 			break;
121 		case 2:
122 			r = 255;
123 			break;
124 		case 3:
125 			g = 255;
126 			break;
127 		case 4:
128 			b = 255;
129 			break;
130 		default:
131 			deRandom rnd;
132 			deRandom_init(&rnd, deInt32Hash(m_curIter));
133 			r = (int)(deRandom_getUint32(&rnd) & 0xFF);
134 			g = (int)(deRandom_getUint32(&rnd) & 0xFF);
135 			b = (int)(deRandom_getUint32(&rnd) & 0xFF);
136 			a = (int)(deRandom_getUint32(&rnd) & 0xFF);
137 			break;
138 
139 	};
140 
141 	glClearColor(float(r)/255.0f, float(g)/255.0f, float(b)/255.0f, float(a)/255.0f);
142 	glClear(GL_COLOR_BUFFER_BIT);
143 
144 	GLU_CHECK_MSG("CLES2 ClearColor failed.");
145 
146 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
147 
148 	return (++m_curIter < m_numIters) ? CONTINUE : STOP;
149 }
150 
151 class ReadPixelsCase : public TestCase
152 {
153 public:
154 										ReadPixelsCase		(Context& context);
155 	virtual								~ReadPixelsCase		(void);
156 	virtual TestCase::IterateResult		iterate				(void);
157 
158 private:
159 	int m_numIters;
160 	int m_curIter;
161 };
162 
ReadPixelsCase(Context & context)163 ReadPixelsCase::ReadPixelsCase (Context& context)
164 	: TestCase(context, "read_pixels", "Read pixels test")
165 	, m_numIters(20)
166 	, m_curIter(0)
167 {
168 }
169 
~ReadPixelsCase(void)170 ReadPixelsCase::~ReadPixelsCase (void)
171 {
172 }
173 
iterate(void)174 TestCase::IterateResult ReadPixelsCase::iterate (void)
175 {
176 	const tcu::RenderTarget&	renderTarget	= m_context.getRenderTarget();
177 	tcu::PixelFormat			pixelFormat		= renderTarget.getPixelFormat();
178 	int							targetWidth		= renderTarget.getWidth();
179 	int							targetHeight	= renderTarget.getHeight();
180 	int							x				= 0;
181 	int							y				= 0;
182 	int							imageWidth		= 0;
183 	int							imageHeight		= 0;
184 
185 	deRandom rnd;
186 	deRandom_init(&rnd, deInt32Hash(m_curIter));
187 
188 	switch (m_curIter)
189 	{
190 		case 0:
191 			// Fullscreen
192 			x = 0;
193 			y = 0;
194 			imageWidth  = targetWidth;
195 			imageHeight = targetHeight;
196 			break;
197 		case 1:
198 			// Upper left corner
199 			x = 0;
200 			y = 0;
201 			imageWidth = targetWidth / 2;
202 			imageHeight = targetHeight / 2;
203 			break;
204 		case 2:
205 			// Lower right corner
206 			x = targetWidth / 2;
207 			y = targetHeight / 2;
208 			imageWidth = targetWidth - x;
209 			imageHeight = targetHeight - y;
210 			break;
211 		default:
212 			x = deRandom_getUint32(&rnd) % (targetWidth - 1);
213 			y = deRandom_getUint32(&rnd) % (targetHeight - 1);
214 			imageWidth = 1 + (deRandom_getUint32(&rnd) % (targetWidth - x - 1));
215 			imageHeight = 1 + (deRandom_getUint32(&rnd) % (targetHeight - y - 1));
216 			break;
217 	}
218 
219 	Surface	resImage(imageWidth, imageHeight);
220 	Surface	refImage(imageWidth, imageHeight);
221 	Surface	diffImage(imageWidth, imageHeight);
222 
223 	int r = (int)(deRandom_getUint32(&rnd) & 0xFF);
224 	int g = (int)(deRandom_getUint32(&rnd) & 0xFF);
225 	int b = (int)(deRandom_getUint32(&rnd) & 0xFF);
226 
227 	tcu::clear(refImage.getAccess(), tcu::IVec4(r, g, b, 255));
228 	glClearColor(float(r)/255.0f, float(g)/255.0f, float(b)/255.0f, 1.0f);
229 	glClear(GL_COLOR_BUFFER_BIT);
230 
231 	glu::readPixels(m_context.getRenderContext(), x, y, resImage.getAccess());
232 	GLU_CHECK_MSG("glReadPixels() failed.");
233 
234 	RGBA colorThreshold = pixelFormat.getColorThreshold();
235 	RGBA matchColor(0, 255, 0, 255);
236 	RGBA diffColor(255, 0, 0, 255);
237 	bool isImageOk = true;
238 
239 	for (int j = 0; j < imageHeight; j++)
240 	{
241 		for (int i = 0; i < imageWidth; i++)
242 		{
243 			RGBA		resRGBA		= resImage.getPixel(i, j);
244 			RGBA		refRGBA		= refImage.getPixel(i, j);
245 			bool		isPixelOk	= compareThreshold(refRGBA, resRGBA, colorThreshold);
246 			diffImage.setPixel(i, j, isPixelOk ? matchColor : diffColor);
247 
248 			isImageOk = isImageOk && isPixelOk;
249 		}
250 	}
251 
252 	if (isImageOk)
253 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
254 	else
255 	{
256 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
257 
258 		m_testCtx.getLog() << TestLog::ImageSet("Result", "Resulting framebuffer")
259 						   << TestLog::Image("Result",		"Resulting framebuffer",	resImage)
260 						   << TestLog::Image("Reference",	"Reference image",			refImage)
261 						   << TestLog::Image("DiffMask",	"Failing pixels",			diffImage)
262 						   << TestLog::EndImageSet;
263 	}
264 
265 	return (++m_curIter < m_numIters) ? CONTINUE : STOP;
266 }
267 
PrerequisiteTests(Context & context)268 PrerequisiteTests::PrerequisiteTests (Context& context)
269 	: TestCaseGroup(context, "prerequisite", "Prerequisite Test Cases")
270 {
271 }
272 
~PrerequisiteTests(void)273 PrerequisiteTests::~PrerequisiteTests (void)
274 {
275 }
276 
init(void)277 void PrerequisiteTests::init (void)
278 {
279 	addChild(new StateResetCase(m_context));
280 	addChild(new ClearColorCase(m_context));
281 	addChild(new ReadPixelsCase(m_context));
282 }
283 
284 } // Functional
285 } // gles3
286 } // deqp
287