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 Texture format tests.
22 *
23 * Constants:
24 * + nearest-neighbor filtering
25 * + no mipmaps
26 * + full texture coordinate range (but not outside) tested
27 * + accessed from fragment shader
28 * + texture unit 0
29 * + named texture object
30 *
31 * Variables:
32 * + texture format
33 * + texture type: 2D or cubemap
34 *//*--------------------------------------------------------------------*/
35
36 #include "es3fTextureFormatTests.hpp"
37 #include "gluPixelTransfer.hpp"
38 #include "gluStrUtil.hpp"
39 #include "gluTexture.hpp"
40 #include "gluTextureUtil.hpp"
41 #include "glsTextureTestUtil.hpp"
42 #include "tcuTextureUtil.hpp"
43 #include "deStringUtil.hpp"
44 #include "deRandom.hpp"
45 #include "glwEnums.hpp"
46 #include "glwFunctions.hpp"
47
48 using std::vector;
49 using std::string;
50 using tcu::TestLog;
51
52 namespace deqp
53 {
54 namespace gles3
55 {
56 namespace Functional
57 {
58
59 using namespace deqp::gls;
60 using namespace deqp::gls::TextureTestUtil;
61 using tcu::Sampler;
62
63 // Texture2DFormatCase
64
65 class Texture2DFormatCase : public tcu::TestCase
66 {
67 public:
68 Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height);
69 Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height);
70 ~Texture2DFormatCase (void);
71
72 void init (void);
73 void deinit (void);
74 IterateResult iterate (void);
75
76 private:
77 Texture2DFormatCase (const Texture2DFormatCase& other);
78 Texture2DFormatCase& operator= (const Texture2DFormatCase& other);
79
80 glu::RenderContext& m_renderCtx;
81
82 deUint32 m_format;
83 deUint32 m_dataType;
84 int m_width;
85 int m_height;
86
87 glu::Texture2D* m_texture;
88 TextureRenderer m_renderer;
89 };
90
Texture2DFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 format,deUint32 dataType,int width,int height)91 Texture2DFormatCase::Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height)
92 : TestCase (testCtx, name, description)
93 , m_renderCtx (renderCtx)
94 , m_format (format)
95 , m_dataType (dataType)
96 , m_width (width)
97 , m_height (height)
98 , m_texture (DE_NULL)
99 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
100 {
101 }
102
Texture2DFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 internalFormat,int width,int height)103 Texture2DFormatCase::Texture2DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height)
104 : TestCase (testCtx, name, description)
105 , m_renderCtx (renderCtx)
106 , m_format (internalFormat)
107 , m_dataType (GL_NONE)
108 , m_width (width)
109 , m_height (height)
110 , m_texture (DE_NULL)
111 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
112 {
113 }
114
~Texture2DFormatCase(void)115 Texture2DFormatCase::~Texture2DFormatCase (void)
116 {
117 deinit();
118 }
119
init(void)120 void Texture2DFormatCase::init (void)
121 {
122 TestLog& log = m_testCtx.getLog();
123 tcu::TextureFormat fmt = m_dataType ? glu::mapGLTransferFormat(m_format, m_dataType) : glu::mapGLInternalFormat(m_format);
124 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(fmt);
125 std::ostringstream fmtName;
126
127 if (m_dataType)
128 fmtName << glu::getTextureFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType);
129 else
130 fmtName << glu::getTextureFormatStr(m_format);
131
132 log << TestLog::Message << "2D texture, " << fmtName.str() << ", " << m_width << "x" << m_height
133 << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient"
134 << TestLog::EndMessage;
135
136 m_texture = m_dataType != GL_NONE
137 ? new glu::Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height) // Implicit internal format.
138 : new glu::Texture2D(m_renderCtx, m_format, m_width, m_height); // Explicit internal format.
139
140 // Fill level 0.
141 m_texture->getRefTexture().allocLevel(0);
142 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax);
143 }
144
deinit(void)145 void Texture2DFormatCase::deinit (void)
146 {
147 delete m_texture;
148 m_texture = DE_NULL;
149
150 m_renderer.clear();
151 }
152
iterate(void)153 Texture2DFormatCase::IterateResult Texture2DFormatCase::iterate (void)
154 {
155 TestLog& log = m_testCtx.getLog();
156 const glw::Functions& gl = m_renderCtx.getFunctions();
157 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName()));
158 tcu::Surface renderedFrame (viewport.width, viewport.height);
159 tcu::Surface referenceFrame (viewport.width, viewport.height);
160 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
161 vector<float> texCoord;
162 ReferenceParams renderParams (TEXTURETYPE_2D);
163 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
164 const deUint32 wrapS = GL_CLAMP_TO_EDGE;
165 const deUint32 wrapT = GL_CLAMP_TO_EDGE;
166 const deUint32 minFilter = GL_NEAREST;
167 const deUint32 magFilter = GL_NEAREST;
168
169 renderParams.flags |= RenderParams::LOG_ALL;
170 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
171 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
172 renderParams.colorScale = spec.lookupScale;
173 renderParams.colorBias = spec.lookupBias;
174
175 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
176
177 log << TestLog::Message << "Texture parameters:"
178 << "\n WRAP_S = " << glu::getTextureParameterValueStr(GL_TEXTURE_WRAP_S, wrapS)
179 << "\n WRAP_T = " << glu::getTextureParameterValueStr(GL_TEXTURE_WRAP_T, wrapT)
180 << "\n MIN_FILTER = " << glu::getTextureParameterValueStr(GL_TEXTURE_MIN_FILTER, minFilter)
181 << "\n MAG_FILTER = " << glu::getTextureParameterValueStr(GL_TEXTURE_MAG_FILTER, magFilter)
182 << TestLog::EndMessage;
183
184 // Setup base viewport.
185 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
186
187 // Upload texture data to GL.
188 m_texture->upload();
189
190 // Bind to unit 0.
191 gl.activeTexture(GL_TEXTURE0);
192 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
193
194 // Setup nearest neighbor filtering and clamp-to-edge.
195 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
196 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
197 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
198 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
199
200 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
201
202 // Draw.
203 m_renderer.renderQuad(0, &texCoord[0], renderParams);
204 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
205 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
206
207 // Compute reference.
208 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
209
210 // Compare and log.
211 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);
212
213 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
214 isOk ? "Pass" : "Image comparison failed");
215
216 return STOP;
217 }
218
219 // TextureCubeFormatCase
220
221 class TextureCubeFormatCase : public tcu::TestCase
222 {
223 public:
224 TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height);
225 TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height);
226 ~TextureCubeFormatCase (void);
227
228 void init (void);
229 void deinit (void);
230 IterateResult iterate (void);
231
232 private:
233 TextureCubeFormatCase (const TextureCubeFormatCase& other);
234 TextureCubeFormatCase& operator= (const TextureCubeFormatCase& other);
235
236 bool testFace (tcu::CubeFace face);
237
238 glu::RenderContext& m_renderCtx;
239
240 deUint32 m_format;
241 deUint32 m_dataType;
242 int m_width;
243 int m_height;
244
245 glu::TextureCube* m_texture;
246 TextureRenderer m_renderer;
247
248 int m_curFace;
249 bool m_isOk;
250 };
251
TextureCubeFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 format,deUint32 dataType,int width,int height)252 TextureCubeFormatCase::TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height)
253 : TestCase (testCtx, name, description)
254 , m_renderCtx (renderCtx)
255 , m_format (format)
256 , m_dataType (dataType)
257 , m_width (width)
258 , m_height (height)
259 , m_texture (DE_NULL)
260 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
261 , m_curFace (0)
262 , m_isOk (false)
263 {
264 }
265
TextureCubeFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 internalFormat,int width,int height)266 TextureCubeFormatCase::TextureCubeFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height)
267 : TestCase (testCtx, name, description)
268 , m_renderCtx (renderCtx)
269 , m_format (internalFormat)
270 , m_dataType (GL_NONE)
271 , m_width (width)
272 , m_height (height)
273 , m_texture (DE_NULL)
274 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
275 , m_curFace (0)
276 , m_isOk (false)
277 {
278 }
279
~TextureCubeFormatCase(void)280 TextureCubeFormatCase::~TextureCubeFormatCase (void)
281 {
282 deinit();
283 }
284
init(void)285 void TextureCubeFormatCase::init (void)
286 {
287 TestLog& log = m_testCtx.getLog();
288 tcu::TextureFormat fmt = m_dataType ? glu::mapGLTransferFormat(m_format, m_dataType) : glu::mapGLInternalFormat(m_format);
289 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(fmt);
290 std::ostringstream fmtName;
291
292 if (m_dataType)
293 fmtName << glu::getTextureFormatStr(m_format) << ", " << glu::getTypeStr(m_dataType);
294 else
295 fmtName << glu::getTextureFormatStr(m_format);
296
297 log << TestLog::Message << "Cube map texture, " << fmtName.str() << ", " << m_width << "x" << m_height
298 << ",\n fill with " << formatGradient(&spec.valueMin, &spec.valueMax) << " gradient"
299 << TestLog::EndMessage;
300
301 DE_ASSERT(m_width == m_height);
302 m_texture = m_dataType != GL_NONE
303 ? new glu::TextureCube(m_renderCtx, m_format, m_dataType, m_width) // Implicit internal format.
304 : new glu::TextureCube(m_renderCtx, m_format, m_width); // Explicit internal format.
305
306 // Fill level 0.
307 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
308 {
309 tcu::Vec4 gMin, gMax;
310
311 switch (face)
312 {
313 case 0: gMin = spec.valueMin.swizzle(0, 1, 2, 3); gMax = spec.valueMax.swizzle(0, 1, 2, 3); break;
314 case 1: gMin = spec.valueMin.swizzle(2, 1, 0, 3); gMax = spec.valueMax.swizzle(2, 1, 0, 3); break;
315 case 2: gMin = spec.valueMin.swizzle(1, 2, 0, 3); gMax = spec.valueMax.swizzle(1, 2, 0, 3); break;
316 case 3: gMin = spec.valueMax.swizzle(0, 1, 2, 3); gMax = spec.valueMin.swizzle(0, 1, 2, 3); break;
317 case 4: gMin = spec.valueMax.swizzle(2, 1, 0, 3); gMax = spec.valueMin.swizzle(2, 1, 0, 3); break;
318 case 5: gMin = spec.valueMax.swizzle(1, 2, 0, 3); gMax = spec.valueMin.swizzle(1, 2, 0, 3); break;
319 default:
320 DE_ASSERT(false);
321 }
322
323 m_texture->getRefTexture().allocLevel((tcu::CubeFace)face, 0);
324 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevelFace(0, (tcu::CubeFace)face), gMin, gMax);
325 }
326
327 // Upload texture data to GL.
328 m_texture->upload();
329
330 // Initialize iteration state.
331 m_curFace = 0;
332 m_isOk = true;
333 }
334
deinit(void)335 void TextureCubeFormatCase::deinit (void)
336 {
337 delete m_texture;
338 m_texture = DE_NULL;
339
340 m_renderer.clear();
341 }
342
testFace(tcu::CubeFace face)343 bool TextureCubeFormatCase::testFace (tcu::CubeFace face)
344 {
345 TestLog& log = m_testCtx.getLog();
346 const glw::Functions& gl = m_renderCtx.getFunctions();
347 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName())+(deUint32)face);
348 tcu::Surface renderedFrame (viewport.width, viewport.height);
349 tcu::Surface referenceFrame (viewport.width, viewport.height);
350 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
351 vector<float> texCoord;
352 ReferenceParams renderParams (TEXTURETYPE_CUBE);
353 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
354
355 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
356 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
357 renderParams.sampler.seamlessCubeMap = true;
358 renderParams.colorScale = spec.lookupScale;
359 renderParams.colorBias = spec.lookupBias;
360
361 // Log render info on first face.
362 if (face == tcu::CUBEFACE_NEGATIVE_X)
363 renderParams.flags |= RenderParams::LOG_ALL;
364
365 computeQuadTexCoordCube(texCoord, face);
366
367 // \todo [2011-10-28 pyry] Image set name / section?
368 log << TestLog::Message << face << TestLog::EndMessage;
369
370 // Setup base viewport.
371 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
372
373 // Bind to unit 0.
374 gl.activeTexture(GL_TEXTURE0);
375 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
376
377 // Setup nearest neighbor filtering and clamp-to-edge.
378 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
379 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
380 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
381 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
382
383 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
384
385 m_renderer.renderQuad(0, &texCoord[0], renderParams);
386 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
387 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
388
389 // Compute reference.
390 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
391
392 // Compare and log.
393 return compareImages(log, referenceFrame, renderedFrame, threshold);
394 }
395
iterate(void)396 TextureCubeFormatCase::IterateResult TextureCubeFormatCase::iterate (void)
397 {
398 // Execute test for all faces.
399 if (!testFace((tcu::CubeFace)m_curFace))
400 m_isOk = false;
401
402 m_curFace += 1;
403
404 if (m_curFace == tcu::CUBEFACE_LAST)
405 {
406 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
407 m_isOk ? "Pass" : "Image comparison failed");
408 return STOP;
409 }
410 else
411 return CONTINUE;
412 }
413
414 // Texture2DArrayFormatCase
415
416 class Texture2DArrayFormatCase : public tcu::TestCase
417 {
418 public:
419 Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int numLayers);
420 Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int numLayers);
421 ~Texture2DArrayFormatCase (void);
422
423 void init (void);
424 void deinit (void);
425 IterateResult iterate (void);
426
427 private:
428 Texture2DArrayFormatCase (const Texture2DArrayFormatCase& other);
429 Texture2DArrayFormatCase& operator= (const Texture2DArrayFormatCase& other);
430
431 bool testLayer (int layerNdx);
432
433 glu::RenderContext& m_renderCtx;
434
435 deUint32 m_format;
436 deUint32 m_dataType;
437 int m_width;
438 int m_height;
439 int m_numLayers;
440
441 glu::Texture2DArray* m_texture;
442 TextureTestUtil::TextureRenderer m_renderer;
443
444 int m_curLayer;
445 };
446
Texture2DArrayFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 format,deUint32 dataType,int width,int height,int numLayers)447 Texture2DArrayFormatCase::Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int numLayers)
448 : TestCase (testCtx, name, description)
449 , m_renderCtx (renderCtx)
450 , m_format (format)
451 , m_dataType (dataType)
452 , m_width (width)
453 , m_height (height)
454 , m_numLayers (numLayers)
455 , m_texture (DE_NULL)
456 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
457 , m_curLayer (0)
458 {
459 }
460
Texture2DArrayFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 internalFormat,int width,int height,int numLayers)461 Texture2DArrayFormatCase::Texture2DArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int numLayers)
462 : TestCase (testCtx, name, description)
463 , m_renderCtx (renderCtx)
464 , m_format (internalFormat)
465 , m_dataType (GL_NONE)
466 , m_width (width)
467 , m_height (height)
468 , m_numLayers (numLayers)
469 , m_texture (DE_NULL)
470 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
471 , m_curLayer (0)
472 {
473 }
474
~Texture2DArrayFormatCase(void)475 Texture2DArrayFormatCase::~Texture2DArrayFormatCase (void)
476 {
477 deinit();
478 }
479
init(void)480 void Texture2DArrayFormatCase::init (void)
481 {
482 m_texture = m_dataType != GL_NONE
483 ? new glu::Texture2DArray(m_renderCtx, m_format, m_dataType, m_width, m_height, m_numLayers) // Implicit internal format.
484 : new glu::Texture2DArray(m_renderCtx, m_format, m_width, m_height, m_numLayers); // Explicit internal format.
485
486 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
487
488 // Fill level 0.
489 m_texture->getRefTexture().allocLevel(0);
490 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax);
491
492 // Initialize state.
493 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
494 m_curLayer = 0;
495 }
496
deinit(void)497 void Texture2DArrayFormatCase::deinit (void)
498 {
499 delete m_texture;
500 m_texture = DE_NULL;
501
502 m_renderer.clear();
503 }
504
testLayer(int layerNdx)505 bool Texture2DArrayFormatCase::testLayer (int layerNdx)
506 {
507 const glw::Functions& gl = m_renderCtx.getFunctions();
508 TestLog& log = m_testCtx.getLog();
509 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName()));
510 tcu::Surface renderedFrame (viewport.width, viewport.height);
511 tcu::Surface referenceFrame (viewport.width, viewport.height);
512 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
513 vector<float> texCoord;
514 ReferenceParams renderParams (TEXTURETYPE_2D_ARRAY);
515 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
516
517 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
518 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
519 renderParams.colorScale = spec.lookupScale;
520 renderParams.colorBias = spec.lookupBias;
521
522 computeQuadTexCoord2DArray(texCoord, layerNdx, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
523
524 // Setup base viewport.
525 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
526
527 // Upload texture data to GL.
528 m_texture->upload();
529
530 // Bind to unit 0.
531 gl.activeTexture(GL_TEXTURE0);
532 gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture->getGLTexture());
533
534 // Setup nearest neighbor filtering and clamp-to-edge.
535 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
536 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
537 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
538 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
539
540 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
541
542 // Draw.
543 m_renderer.renderQuad(0, &texCoord[0], renderParams);
544 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
545
546 // Compute reference.
547 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
548
549 // Compare and log.
550 return compareImages(log, (string("Layer" + de::toString(layerNdx))).c_str(), (string("Layer " + de::toString(layerNdx))).c_str(), referenceFrame, renderedFrame, threshold);
551 }
552
iterate(void)553 Texture2DArrayFormatCase::IterateResult Texture2DArrayFormatCase::iterate (void)
554 {
555 // Execute test for all layers.
556 bool isOk = testLayer(m_curLayer);
557
558 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
559 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
560
561 m_curLayer += 1;
562
563 return m_curLayer < m_texture->getRefTexture().getNumLayers() ? CONTINUE : STOP;
564 }
565
566 // Texture2DFormatCase
567
568 class Texture3DFormatCase : public tcu::TestCase
569 {
570 public:
571 Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int depth);
572 Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int depth);
573 ~Texture3DFormatCase (void);
574
575 void init (void);
576 void deinit (void);
577 IterateResult iterate (void);
578
579 private:
580 Texture3DFormatCase (const Texture3DFormatCase& other);
581 Texture3DFormatCase& operator= (const Texture3DFormatCase& other);
582
583 bool testSlice (int sliceNdx);
584
585 glu::RenderContext& m_renderCtx;
586
587 deUint32 m_format;
588 deUint32 m_dataType;
589 int m_width;
590 int m_height;
591 int m_depth;
592
593 glu::Texture3D* m_texture;
594 TextureTestUtil::TextureRenderer m_renderer;
595
596 int m_curSlice;
597 };
598
Texture3DFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 format,deUint32 dataType,int width,int height,int depth)599 Texture3DFormatCase::Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 format, deUint32 dataType, int width, int height, int depth)
600 : TestCase (testCtx, name, description)
601 , m_renderCtx (renderCtx)
602 , m_format (format)
603 , m_dataType (dataType)
604 , m_width (width)
605 , m_height (height)
606 , m_depth (depth)
607 , m_texture (DE_NULL)
608 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
609 , m_curSlice (0)
610 {
611 }
612
Texture3DFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const char * name,const char * description,deUint32 internalFormat,int width,int height,int depth)613 Texture3DFormatCase::Texture3DFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width, int height, int depth)
614 : TestCase (testCtx, name, description)
615 , m_renderCtx (renderCtx)
616 , m_format (internalFormat)
617 , m_dataType (GL_NONE)
618 , m_width (width)
619 , m_height (height)
620 , m_depth (depth)
621 , m_texture (DE_NULL)
622 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
623 , m_curSlice (0)
624 {
625 }
626
~Texture3DFormatCase(void)627 Texture3DFormatCase::~Texture3DFormatCase (void)
628 {
629 deinit();
630 }
631
init(void)632 void Texture3DFormatCase::init (void)
633 {
634 m_texture = m_dataType != GL_NONE
635 ? new glu::Texture3D(m_renderCtx, m_format, m_dataType, m_width, m_height, m_depth) // Implicit internal format.
636 : new glu::Texture3D(m_renderCtx, m_format, m_width, m_height, m_depth); // Explicit internal format.
637
638 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
639
640 // Fill level 0.
641 m_texture->getRefTexture().allocLevel(0);
642 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax);
643
644 // Initialize state.
645 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
646 m_curSlice = 0;
647 }
648
deinit(void)649 void Texture3DFormatCase::deinit (void)
650 {
651 delete m_texture;
652 m_texture = DE_NULL;
653
654 m_renderer.clear();
655 }
656
testSlice(int sliceNdx)657 bool Texture3DFormatCase::testSlice (int sliceNdx)
658 {
659 TestLog& log = m_testCtx.getLog();
660 const glw::Functions& gl = m_renderCtx.getFunctions();
661 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, m_height, deStringHash(getName()));
662 tcu::Surface renderedFrame (viewport.width, viewport.height);
663 tcu::Surface referenceFrame (viewport.width, viewport.height);
664 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
665 vector<float> texCoord;
666 ReferenceParams renderParams (TEXTURETYPE_3D);
667 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
668 float r = ((float)sliceNdx + 0.5f) / (float)m_depth;
669
670 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
671 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
672 renderParams.colorScale = spec.lookupScale;
673 renderParams.colorBias = spec.lookupBias;
674
675 computeQuadTexCoord3D(texCoord, tcu::Vec3(0.0f, 0.0f, r), tcu::Vec3(1.0f, 1.0f, r), tcu::IVec3(0,1,2));
676
677 // Setup base viewport.
678 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
679
680 // Upload texture data to GL.
681 m_texture->upload();
682
683 // Bind to unit 0.
684 gl.activeTexture(GL_TEXTURE0);
685 gl.bindTexture(GL_TEXTURE_3D, m_texture->getGLTexture());
686
687 // Setup nearest neighbor filtering and clamp-to-edge.
688 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
689 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
690 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
691 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
692
693 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
694
695 // Draw.
696 m_renderer.renderQuad(0, &texCoord[0], renderParams);
697 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
698
699 // Compute reference.
700 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
701
702 // Compare and log.
703 return compareImages(log, (string("Slice" + de::toString(sliceNdx))).c_str(), (string("Slice " + de::toString(sliceNdx))).c_str(), referenceFrame, renderedFrame, threshold);
704 }
705
iterate(void)706 Texture3DFormatCase::IterateResult Texture3DFormatCase::iterate (void)
707 {
708 // Execute test for all slices.
709 bool isOk = testSlice(m_curSlice);
710
711 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
712 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
713
714 m_curSlice += 1;
715
716 return m_curSlice < m_texture->getRefTexture().getDepth() ? CONTINUE : STOP;
717 }
718
719 // Compressed2FormatCase
720
721 class Compressed2DFormatCase : public tcu::TestCase
722 {
723 public:
724 Compressed2DFormatCase (tcu::TestContext& testCtx,
725 glu::RenderContext& renderCtx,
726 const glu::ContextInfo& renderCtxInfo,
727 const char* name,
728 const char* description,
729 tcu::CompressedTexFormat format,
730 deUint32 randomSeed,
731 int width,
732 int height);
733 ~Compressed2DFormatCase (void);
734
735 void init (void);
736 void deinit (void);
737 IterateResult iterate (void);
738
739 private:
740 Compressed2DFormatCase (const Compressed2DFormatCase& other);
741 Compressed2DFormatCase& operator= (const Compressed2DFormatCase& other);
742
743 glu::RenderContext& m_renderCtx;
744 const glu::ContextInfo& m_renderCtxInfo;
745
746 tcu::CompressedTexFormat m_format;
747
748 deUint32 m_randomSeed;
749 int m_width;
750 int m_height;
751
752 glu::Texture2D* m_texture;
753 TextureTestUtil::TextureRenderer m_renderer;
754 };
755
Compressed2DFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const glu::ContextInfo & renderCtxInfo,const char * name,const char * description,tcu::CompressedTexFormat format,deUint32 randomSeed,int width,int height)756 Compressed2DFormatCase::Compressed2DFormatCase (tcu::TestContext& testCtx,
757 glu::RenderContext& renderCtx,
758 const glu::ContextInfo& renderCtxInfo,
759 const char* name,
760 const char* description,
761 tcu::CompressedTexFormat format,
762 deUint32 randomSeed,
763 int width,
764 int height)
765 : TestCase (testCtx, name, description)
766 , m_renderCtx (renderCtx)
767 , m_renderCtxInfo (renderCtxInfo)
768 , m_format (format)
769 , m_randomSeed (randomSeed)
770 , m_width (width)
771 , m_height (height)
772 , m_texture (DE_NULL)
773 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
774 {
775 }
776
~Compressed2DFormatCase(void)777 Compressed2DFormatCase::~Compressed2DFormatCase (void)
778 {
779 deinit();
780 }
781
init(void)782 void Compressed2DFormatCase::init (void)
783 {
784 // Create texture.
785 tcu::CompressedTexture compressedTexture (m_format, m_width, m_height);
786 int dataSize = compressedTexture.getDataSize();
787 deUint8* data = (deUint8*)compressedTexture.getData();
788 de::Random rnd (m_randomSeed);
789
790 for (int i = 0; i < dataSize; i++)
791 data[i] = rnd.getUint32() & 0xff;
792
793 m_texture = new glu::Texture2D(m_renderCtx, m_renderCtxInfo, 1, &compressedTexture);
794 }
795
deinit(void)796 void Compressed2DFormatCase::deinit (void)
797 {
798 delete m_texture;
799 m_texture = DE_NULL;
800
801 m_renderer.clear();
802 }
803
iterate(void)804 Compressed2DFormatCase::IterateResult Compressed2DFormatCase::iterate (void)
805 {
806 const glw::Functions& gl = m_renderCtx.getFunctions();
807 TestLog& log = m_testCtx.getLog();
808 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName()));
809 tcu::Surface renderedFrame (viewport.width, viewport.height);
810 tcu::Surface referenceFrame (viewport.width, viewport.height);
811 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
812 vector<float> texCoord;
813 ReferenceParams renderParams (TEXTURETYPE_2D);
814 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
815
816 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
817 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
818 renderParams.colorScale = spec.lookupScale;
819 renderParams.colorBias = spec.lookupBias;
820
821 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
822
823 // Setup base viewport.
824 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
825
826 // Bind to unit 0.
827 gl.activeTexture(GL_TEXTURE0);
828 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
829
830 // Setup nearest neighbor filtering and clamp-to-edge.
831 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
832 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
833 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
834 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
835
836 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
837
838 // Draw.
839 m_renderer.renderQuad(0, &texCoord[0], renderParams);
840 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
841
842 // Compute reference.
843 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
844
845 // Compare and log.
846 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);
847
848 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
849 isOk ? "Pass" : "Image comparison failed");
850
851 return STOP;
852 }
853
854 // CompressedCubeFormatCase
855
856 class CompressedCubeFormatCase : public tcu::TestCase
857 {
858 public:
859 CompressedCubeFormatCase (tcu::TestContext& testCtx,
860 glu::RenderContext& renderCtx,
861 const glu::ContextInfo& renderCtxInfo,
862 const char* name,
863 const char* description,
864 tcu::CompressedTexFormat format,
865 deUint32 randomSeed,
866 int width,
867 int height);
868
869 ~CompressedCubeFormatCase (void);
870
871 void init (void);
872 void deinit (void);
873 IterateResult iterate (void);
874
875 private:
876 CompressedCubeFormatCase (const CompressedCubeFormatCase& other);
877 CompressedCubeFormatCase& operator= (const CompressedCubeFormatCase& other);
878
879 bool testFace (tcu::CubeFace face);
880
881 glu::RenderContext& m_renderCtx;
882 const glu::ContextInfo& m_renderCtxInfo;
883
884 tcu::CompressedTexFormat m_format;
885
886 deUint32 m_randomSeed;
887 int m_width;
888 int m_height;
889
890 glu::TextureCube* m_texture;
891 TextureTestUtil::TextureRenderer m_renderer;
892
893 int m_curFace;
894 bool m_isOk;
895 };
896
CompressedCubeFormatCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const glu::ContextInfo & renderCtxInfo,const char * name,const char * description,tcu::CompressedTexFormat format,deUint32 randomSeed,int width,int height)897 CompressedCubeFormatCase::CompressedCubeFormatCase (tcu::TestContext& testCtx,
898 glu::RenderContext& renderCtx,
899 const glu::ContextInfo& renderCtxInfo,
900 const char* name,
901 const char* description,
902 tcu::CompressedTexFormat format,
903 deUint32 randomSeed,
904 int width,
905 int height)
906 : TestCase (testCtx, name, description)
907 , m_renderCtx (renderCtx)
908 , m_renderCtxInfo (renderCtxInfo)
909 , m_format (format)
910 , m_randomSeed (randomSeed)
911 , m_width (width)
912 , m_height (height)
913 , m_texture (DE_NULL)
914 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
915 , m_curFace (0)
916 , m_isOk (false)
917 {
918 }
919
~CompressedCubeFormatCase(void)920 CompressedCubeFormatCase::~CompressedCubeFormatCase (void)
921 {
922 deinit();
923 }
924
init(void)925 void CompressedCubeFormatCase::init (void)
926 {
927 vector<tcu::CompressedTexture> levels (tcu::CUBEFACE_LAST);
928 de::Random rnd (m_randomSeed);
929
930 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
931 {
932 levels[face].setStorage(m_format, m_width, m_height);
933
934 int dataSize = levels[face].getDataSize();
935 deUint8* data = (deUint8*)levels[face].getData();
936
937 for (int i = 0; i < dataSize; i++)
938 data[i] = rnd.getUint32() & 0xff;
939 }
940
941 m_texture = new glu::TextureCube(m_renderCtx, m_renderCtxInfo, 1, &levels[0]);
942
943 m_curFace = 0;
944 m_isOk = true;
945 }
946
deinit(void)947 void CompressedCubeFormatCase::deinit (void)
948 {
949 delete m_texture;
950 m_texture = DE_NULL;
951
952 m_renderer.clear();
953 }
954
testFace(tcu::CubeFace face)955 bool CompressedCubeFormatCase::testFace (tcu::CubeFace face)
956 {
957 const glw::Functions& gl = m_renderCtx.getFunctions();
958 TestLog& log = m_testCtx.getLog();
959 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getSize(), m_texture->getRefTexture().getSize(), deStringHash(getName())+(deUint32)face);
960 tcu::Surface renderedFrame (viewport.width, viewport.height);
961 tcu::Surface referenceFrame (viewport.width, viewport.height);
962 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
963 vector<float> texCoord;
964 ReferenceParams renderParams (TEXTURETYPE_CUBE);
965 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
966
967 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat());
968 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
969 renderParams.sampler.seamlessCubeMap = true;
970 renderParams.colorScale = spec.lookupScale;
971 renderParams.colorBias = spec.lookupBias;
972
973 computeQuadTexCoordCube(texCoord, face);
974
975 log << TestLog::Message << face << TestLog::EndMessage;
976
977 // Setup base viewport.
978 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
979
980 // Bind to unit 0.
981 gl.activeTexture(GL_TEXTURE0);
982 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
983
984 // Setup nearest neighbor filtering and clamp-to-edge.
985 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
986 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
987 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
988 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
989
990 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
991
992 m_renderer.renderQuad(0, &texCoord[0], renderParams);
993 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
994
995 // Compute reference.
996 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams);
997
998 // Compare and log.
999 return compareImages(log, referenceFrame, renderedFrame, threshold);
1000 }
1001
iterate(void)1002 CompressedCubeFormatCase::IterateResult CompressedCubeFormatCase::iterate (void)
1003 {
1004 // Execute test for all faces.
1005 if (!testFace((tcu::CubeFace)m_curFace))
1006 m_isOk = false;
1007
1008 m_curFace += 1;
1009
1010 if (m_curFace == tcu::CUBEFACE_LAST)
1011 {
1012 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
1013 m_isOk ? "Pass" : "Image comparison failed");
1014 return STOP;
1015 }
1016 else
1017 return CONTINUE;
1018 }
1019
1020 // Texture2DFileCase
1021
1022 class Texture2DFileCase : public tcu::TestCase
1023 {
1024 public:
1025 Texture2DFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames);
1026 ~Texture2DFileCase (void);
1027
1028 void init (void);
1029 void deinit (void);
1030 IterateResult iterate (void);
1031
1032 private:
1033 Texture2DFileCase (const Texture2DFileCase& other);
1034 Texture2DFileCase& operator= (const Texture2DFileCase& other);
1035
1036 glu::RenderContext& m_renderCtx;
1037 const glu::ContextInfo& m_renderCtxInfo;
1038
1039 std::vector<std::string> m_filenames;
1040
1041 glu::Texture2D* m_texture;
1042 TextureRenderer m_renderer;
1043 };
1044
Texture2DFileCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const glu::ContextInfo & renderCtxInfo,const char * name,const char * description,const std::vector<std::string> & filenames)1045 Texture2DFileCase::Texture2DFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames)
1046 : TestCase (testCtx, name, description)
1047 , m_renderCtx (renderCtx)
1048 , m_renderCtxInfo (renderCtxInfo)
1049 , m_filenames (filenames)
1050 , m_texture (DE_NULL)
1051 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
1052 {
1053 }
1054
~Texture2DFileCase(void)1055 Texture2DFileCase::~Texture2DFileCase (void)
1056 {
1057 deinit();
1058 }
1059
init(void)1060 void Texture2DFileCase::init (void)
1061 {
1062 // Create texture.
1063 m_texture = glu::Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size(), m_filenames);
1064 }
1065
deinit(void)1066 void Texture2DFileCase::deinit (void)
1067 {
1068 delete m_texture;
1069 m_texture = DE_NULL;
1070
1071 m_renderer.clear();
1072 }
1073
iterate(void)1074 Texture2DFileCase::IterateResult Texture2DFileCase::iterate (void)
1075 {
1076 const glw::Functions& gl = m_renderCtx.getFunctions();
1077 TestLog& log = m_testCtx.getLog();
1078 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName()));
1079 tcu::Surface renderedFrame (viewport.width, viewport.height);
1080 tcu::Surface referenceFrame (viewport.width, viewport.height);
1081 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
1082 vector<float> texCoord;
1083
1084 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));
1085
1086 // Setup base viewport.
1087 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
1088
1089 // Bind to unit 0.
1090 gl.activeTexture(GL_TEXTURE0);
1091 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
1092
1093 // Setup nearest neighbor filtering and clamp-to-edge.
1094 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1095 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1096 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1097 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1098
1099 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
1100
1101 // Draw.
1102 m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_2D);
1103 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
1104 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
1105
1106 // Compute reference.
1107 ReferenceParams refParams(TEXTURETYPE_2D);
1108 refParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
1109 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], refParams);
1110
1111 // Compare and log.
1112 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);
1113
1114 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
1115 isOk ? "Pass" : "Image comparison failed");
1116
1117 return STOP;
1118 }
1119
1120 // TextureCubeFileCase
1121
1122 class TextureCubeFileCase : public tcu::TestCase
1123 {
1124 public:
1125 TextureCubeFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames);
1126 ~TextureCubeFileCase (void);
1127
1128 void init (void);
1129 void deinit (void);
1130 IterateResult iterate (void);
1131
1132 private:
1133 TextureCubeFileCase (const TextureCubeFileCase& other);
1134 TextureCubeFileCase& operator= (const TextureCubeFileCase& other);
1135
1136 bool testFace (tcu::CubeFace face);
1137
1138 glu::RenderContext& m_renderCtx;
1139 const glu::ContextInfo& m_renderCtxInfo;
1140
1141 std::vector<std::string> m_filenames;
1142
1143 glu::TextureCube* m_texture;
1144 TextureRenderer m_renderer;
1145
1146 int m_curFace;
1147 bool m_isOk;
1148 };
1149
TextureCubeFileCase(tcu::TestContext & testCtx,glu::RenderContext & renderCtx,const glu::ContextInfo & renderCtxInfo,const char * name,const char * description,const std::vector<std::string> & filenames)1150 TextureCubeFileCase::TextureCubeFileCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, const std::vector<std::string>& filenames)
1151 : TestCase (testCtx, name, description)
1152 , m_renderCtx (renderCtx)
1153 , m_renderCtxInfo (renderCtxInfo)
1154 , m_filenames (filenames)
1155 , m_texture (DE_NULL)
1156 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
1157 , m_curFace (0)
1158 , m_isOk (false)
1159 {
1160 }
1161
~TextureCubeFileCase(void)1162 TextureCubeFileCase::~TextureCubeFileCase (void)
1163 {
1164 deinit();
1165 }
1166
init(void)1167 void TextureCubeFileCase::init (void)
1168 {
1169 // Create texture.
1170 DE_ASSERT(m_filenames.size() % 6 == 0);
1171 m_texture = glu::TextureCube::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size()/6, m_filenames);
1172
1173 m_curFace = 0;
1174 m_isOk = true;
1175 }
1176
deinit(void)1177 void TextureCubeFileCase::deinit (void)
1178 {
1179 delete m_texture;
1180 m_texture = DE_NULL;
1181
1182 m_renderer.clear();
1183 }
1184
testFace(tcu::CubeFace face)1185 bool TextureCubeFileCase::testFace (tcu::CubeFace face)
1186 {
1187 const glw::Functions& gl = m_renderCtx.getFunctions();
1188 TestLog& log = m_testCtx.getLog();
1189 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_texture->getRefTexture().getSize(), m_texture->getRefTexture().getSize(), deStringHash(getName())+(deUint32)face);
1190 tcu::Surface renderedFrame (viewport.width, viewport.height);
1191 tcu::Surface referenceFrame (viewport.width, viewport.height);
1192 Sampler sampler (Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST);
1193 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
1194 vector<float> texCoord;
1195
1196 computeQuadTexCoordCube(texCoord, face);
1197
1198 // \todo [2011-10-28 pyry] Image set name / section?
1199 log << TestLog::Message << face << TestLog::EndMessage;
1200
1201 // Setup base viewport.
1202 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
1203
1204 // Bind to unit 0.
1205 gl.activeTexture(GL_TEXTURE0);
1206 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
1207
1208 // Setup nearest neighbor filtering and clamp-to-edge.
1209 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1210 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1211 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1212 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1213
1214 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
1215
1216 m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_CUBE);
1217 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
1218 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
1219
1220 // Compute reference.
1221 sampleTexture(SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], ReferenceParams(TEXTURETYPE_CUBE, sampler));
1222
1223 // Compare and log.
1224 return compareImages(log, referenceFrame, renderedFrame, threshold);
1225 }
1226
iterate(void)1227 TextureCubeFileCase::IterateResult TextureCubeFileCase::iterate (void)
1228 {
1229 // Execute test for all faces.
1230 if (!testFace((tcu::CubeFace)m_curFace))
1231 m_isOk = false;
1232
1233 m_curFace += 1;
1234
1235 if (m_curFace == tcu::CUBEFACE_LAST)
1236 {
1237 m_testCtx.setTestResult(m_isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
1238 m_isOk ? "Pass" : "Image comparison failed");
1239 return STOP;
1240 }
1241 else
1242 return CONTINUE;
1243 }
1244
1245 // TextureFormatTests
1246
TextureFormatTests(Context & context)1247 TextureFormatTests::TextureFormatTests (Context& context)
1248 : TestCaseGroup(context, "format", "Texture Format Tests")
1249 {
1250 }
1251
~TextureFormatTests(void)1252 TextureFormatTests::~TextureFormatTests (void)
1253 {
1254 }
1255
toStringVector(const char * const * str,int numStr)1256 vector<string> toStringVector (const char* const* str, int numStr)
1257 {
1258 vector<string> v;
1259 v.resize(numStr);
1260 for (int i = 0; i < numStr; i++)
1261 v[i] = str[i];
1262 return v;
1263 }
1264
init(void)1265 void TextureFormatTests::init (void)
1266 {
1267 tcu::TestCaseGroup* unsizedGroup = DE_NULL;
1268 tcu::TestCaseGroup* sizedGroup = DE_NULL;
1269 tcu::TestCaseGroup* compressedGroup = DE_NULL;
1270 addChild((unsizedGroup = new tcu::TestCaseGroup(m_testCtx, "unsized", "Unsized formats")));
1271 addChild((sizedGroup = new tcu::TestCaseGroup(m_testCtx, "sized", "Sized formats")));
1272 addChild((compressedGroup = new tcu::TestCaseGroup(m_testCtx, "compressed", "Compressed formats")));
1273
1274 tcu::TestCaseGroup* sized2DGroup = DE_NULL;
1275 tcu::TestCaseGroup* sizedCubeGroup = DE_NULL;
1276 tcu::TestCaseGroup* sized2DArrayGroup = DE_NULL;
1277 tcu::TestCaseGroup* sized3DGroup = DE_NULL;
1278 sizedGroup->addChild((sized2DGroup = new tcu::TestCaseGroup(m_testCtx, "2d", "Sized formats (2D)")));
1279 sizedGroup->addChild((sizedCubeGroup = new tcu::TestCaseGroup(m_testCtx, "cube", "Sized formats (Cubemap)")));
1280 sizedGroup->addChild((sized2DArrayGroup = new tcu::TestCaseGroup(m_testCtx, "2d_array", "Sized formats (2D Array)")));
1281 sizedGroup->addChild((sized3DGroup = new tcu::TestCaseGroup(m_testCtx, "3d", "Sized formats (3D)")));
1282
1283 struct
1284 {
1285 const char* name;
1286 deUint32 format;
1287 deUint32 dataType;
1288 } texFormats[] =
1289 {
1290 { "alpha", GL_ALPHA, GL_UNSIGNED_BYTE },
1291 { "luminance", GL_LUMINANCE, GL_UNSIGNED_BYTE },
1292 { "luminance_alpha", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE },
1293 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
1294 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE },
1295 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
1296 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 },
1297 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE }
1298 };
1299
1300 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(texFormats); formatNdx++)
1301 {
1302 deUint32 format = texFormats[formatNdx].format;
1303 deUint32 dataType = texFormats[formatNdx].dataType;
1304 string nameBase = texFormats[formatNdx].name;
1305 string descriptionBase = string(glu::getTextureFormatName(format)) + ", " + glu::getTypeName(dataType);
1306
1307 unsizedGroup->addChild(new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), format, dataType, 128, 128));
1308 unsizedGroup->addChild(new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), format, dataType, 63, 112));
1309 unsizedGroup->addChild(new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_cube_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), format, dataType, 64, 64));
1310 unsizedGroup->addChild(new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_cube_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), format, dataType, 57, 57));
1311 unsizedGroup->addChild(new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_array_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), format, dataType, 64, 64, 8));
1312 unsizedGroup->addChild(new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_2d_array_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), format, dataType, 63, 57, 7));
1313 unsizedGroup->addChild(new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_3d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), format, dataType, 8, 32, 16));
1314 unsizedGroup->addChild(new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_3d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), format, dataType, 11, 31, 7));
1315 }
1316
1317 struct
1318 {
1319 const char* name;
1320 deUint32 internalFormat;
1321 } sizedColorFormats[] =
1322 {
1323 { "rgba32f", GL_RGBA32F, },
1324 { "rgba32i", GL_RGBA32I, },
1325 { "rgba32ui", GL_RGBA32UI, },
1326 { "rgba16f", GL_RGBA16F, },
1327 { "rgba16i", GL_RGBA16I, },
1328 { "rgba16ui", GL_RGBA16UI, },
1329 { "rgba8", GL_RGBA8, },
1330 { "rgba8i", GL_RGBA8I, },
1331 { "rgba8ui", GL_RGBA8UI, },
1332 { "srgb8_alpha8", GL_SRGB8_ALPHA8, },
1333 { "rgb10_a2", GL_RGB10_A2, },
1334 { "rgb10_a2ui", GL_RGB10_A2UI, },
1335 { "rgba4", GL_RGBA4, },
1336 { "rgb5_a1", GL_RGB5_A1, },
1337 { "rgba8_snorm", GL_RGBA8_SNORM, },
1338 { "rgb8", GL_RGB8, },
1339 { "rgb565", GL_RGB565, },
1340 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, },
1341 { "rgb32f", GL_RGB32F, },
1342 { "rgb32i", GL_RGB32I, },
1343 { "rgb32ui", GL_RGB32UI, },
1344 { "rgb16f", GL_RGB16F, },
1345 { "rgb16i", GL_RGB16I, },
1346 { "rgb16ui", GL_RGB16UI, },
1347 { "rgb8_snorm", GL_RGB8_SNORM, },
1348 { "rgb8i", GL_RGB8I, },
1349 { "rgb8ui", GL_RGB8UI, },
1350 { "srgb8", GL_SRGB8, },
1351 { "rgb9_e5", GL_RGB9_E5, },
1352 { "rg32f", GL_RG32F, },
1353 { "rg32i", GL_RG32I, },
1354 { "rg32ui", GL_RG32UI, },
1355 { "rg16f", GL_RG16F, },
1356 { "rg16i", GL_RG16I, },
1357 { "rg16ui", GL_RG16UI, },
1358 { "rg8", GL_RG8, },
1359 { "rg8i", GL_RG8I, },
1360 { "rg8ui", GL_RG8UI, },
1361 { "rg8_snorm", GL_RG8_SNORM, },
1362 { "r32f", GL_R32F, },
1363 { "r32i", GL_R32I, },
1364 { "r32ui", GL_R32UI, },
1365 { "r16f", GL_R16F, },
1366 { "r16i", GL_R16I, },
1367 { "r16ui", GL_R16UI, },
1368 { "r8", GL_R8, },
1369 { "r8i", GL_R8I, },
1370 { "r8ui", GL_R8UI, },
1371 { "r8_snorm", GL_R8_SNORM, }
1372 };
1373
1374 struct
1375 {
1376 const char* name;
1377 deUint32 internalFormat;
1378 } sizedDepthStencilFormats[] =
1379 {
1380 // Depth and stencil formats
1381 { "depth_component32f", GL_DEPTH_COMPONENT32F },
1382 { "depth_component24", GL_DEPTH_COMPONENT24 },
1383 { "depth_component16", GL_DEPTH_COMPONENT16 },
1384 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 },
1385 { "depth24_stencil8", GL_DEPTH24_STENCIL8 }
1386 };
1387
1388 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedColorFormats); formatNdx++)
1389 {
1390 deUint32 internalFormat = sizedColorFormats[formatNdx].internalFormat;
1391 string nameBase = sizedColorFormats[formatNdx].name;
1392 string descriptionBase = glu::getTextureFormatName(internalFormat);
1393
1394 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 128, 128));
1395 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 63, 112));
1396 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 64, 64));
1397 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 57, 57));
1398 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 64, 64, 8));
1399 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 63, 57, 7));
1400 sized3DGroup->addChild (new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), internalFormat, 8, 32, 16));
1401 sized3DGroup->addChild (new Texture3DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_3D").c_str(), internalFormat, 11, 31, 7));
1402 }
1403
1404 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedDepthStencilFormats); formatNdx++)
1405 {
1406 deUint32 internalFormat = sizedDepthStencilFormats[formatNdx].internalFormat;
1407 string nameBase = sizedDepthStencilFormats[formatNdx].name;
1408 string descriptionBase = glu::getTextureFormatName(internalFormat);
1409
1410 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 128, 128));
1411 sized2DGroup->addChild (new Texture2DFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), internalFormat, 63, 112));
1412 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 64, 64));
1413 sizedCubeGroup->addChild (new TextureCubeFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), internalFormat, 57, 57));
1414 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 64, 64, 8));
1415 sized2DArrayGroup->addChild (new Texture2DArrayFormatCase (m_testCtx, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D_ARRAY").c_str(), internalFormat, 63, 57, 7));
1416 }
1417
1418 // ETC-1 compressed formats.
1419 {
1420 static const char* filenames[] =
1421 {
1422 "data/etc1/photo_helsinki_mip_0.pkm",
1423 "data/etc1/photo_helsinki_mip_1.pkm",
1424 "data/etc1/photo_helsinki_mip_2.pkm",
1425 "data/etc1/photo_helsinki_mip_3.pkm",
1426 "data/etc1/photo_helsinki_mip_4.pkm",
1427 "data/etc1/photo_helsinki_mip_5.pkm",
1428 "data/etc1/photo_helsinki_mip_6.pkm",
1429 "data/etc1/photo_helsinki_mip_7.pkm"
1430 };
1431 compressedGroup->addChild(new Texture2DFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_2d_pot", "GL_ETC1_RGB8_OES, GL_TEXTURE_2D", toStringVector(filenames, DE_LENGTH_OF_ARRAY(filenames))));
1432 }
1433
1434 {
1435 vector<string> filenames;
1436 filenames.push_back("data/etc1/photo_helsinki_113x89.pkm");
1437 compressedGroup->addChild(new Texture2DFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_2d_npot", "GL_ETC1_RGB8_OES, GL_TEXTURE_2D", filenames));
1438 }
1439
1440 {
1441 static const char* faceExt[] = { "neg_x", "pos_x", "neg_y", "pos_y", "neg_z", "pos_z" };
1442
1443 const int potNumLevels = 7;
1444 vector<string> potFilenames;
1445 for (int level = 0; level < potNumLevels; level++)
1446 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
1447 potFilenames.push_back(string("data/etc1/skybox_") + faceExt[face] + "_mip_" + de::toString(level) + ".pkm");
1448
1449 compressedGroup->addChild(new TextureCubeFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_pot", "GL_ETC1_RGB8_OES, GL_TEXTURE_CUBE_MAP", potFilenames));
1450
1451 vector<string> npotFilenames;
1452 for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
1453 npotFilenames.push_back(string("data/etc1/skybox_61x61_") + faceExt[face] + ".pkm");
1454
1455 compressedGroup->addChild(new TextureCubeFileCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), "etc1_cube_npot", "GL_ETC_RGB8_OES, GL_TEXTURE_CUBE_MAP", npotFilenames));
1456 }
1457
1458 // ETC-2 and EAC compressed formats.
1459 struct {
1460 const char* descriptionBase;
1461 const char* nameBase;
1462 tcu::CompressedTexFormat format;
1463 } etc2Formats[] =
1464 {
1465 { "GL_COMPRESSED_R11_EAC", "eac_r11", tcu::COMPRESSEDTEXFORMAT_EAC_R11, },
1466 { "GL_COMPRESSED_SIGNED_R11_EAC", "eac_signed_r11", tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11, },
1467 { "GL_COMPRESSED_RG11_EAC", "eac_rg11", tcu::COMPRESSEDTEXFORMAT_EAC_RG11, },
1468 { "GL_COMPRESSED_SIGNED_RG11_EAC", "eac_signed_rg11", tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11, },
1469 { "GL_COMPRESSED_RGB8_ETC2", "etc2_rgb8", tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8, },
1470 { "GL_COMPRESSED_SRGB8_ETC2", "etc2_srgb8", tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8, },
1471 { "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", "etc2_rgb8_punchthrough_alpha1", tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1, },
1472 { "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", "etc2_srgb8_punchthrough_alpha1", tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1, },
1473 { "GL_COMPRESSED_RGBA8_ETC2_EAC", "etc2_eac_rgba8", tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8, },
1474 { "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", "etc2_eac_srgb8_alpha8", tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8, }
1475 };
1476
1477 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(etc2Formats); formatNdx++)
1478 {
1479 string descriptionBase = etc2Formats[formatNdx].descriptionBase;
1480 string nameBase = etc2Formats[formatNdx].nameBase;
1481
1482 compressedGroup->addChild(new Compressed2DFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_2d_pot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), etc2Formats[formatNdx].format, 1, 128, 64));
1483 compressedGroup->addChild(new CompressedCubeFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), etc2Formats[formatNdx].format, 1, 64, 64));
1484 compressedGroup->addChild(new Compressed2DFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_2d_npot").c_str(), (descriptionBase + ", GL_TEXTURE_2D").c_str(), etc2Formats[formatNdx].format, 1, 51, 65));
1485 compressedGroup->addChild(new CompressedCubeFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP").c_str(), etc2Formats[formatNdx].format, 1, 51, 51));
1486 }
1487
1488
1489 }
1490
1491 } // Functional
1492 } // gles3
1493 } // deqp
1494