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