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