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