1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 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 24#include "es31fTextureFormatTests.hpp" 25#include "gluContextInfo.hpp" 26#include "gluPixelTransfer.hpp" 27#include "gluStrUtil.hpp" 28#include "gluTexture.hpp" 29#include "gluTextureUtil.hpp" 30#include "glsTextureTestUtil.hpp" 31#include "tcuTextureUtil.hpp" 32#include "deStringUtil.hpp" 33#include "deRandom.hpp" 34#include "glwEnums.hpp" 35#include "glwFunctions.hpp" 36 37using std::vector; 38using std::string; 39using tcu::TestLog; 40 41namespace deqp 42{ 43namespace gles31 44{ 45namespace Functional 46{ 47 48using namespace deqp::gls; 49using namespace deqp::gls::TextureTestUtil; 50using namespace glu::TextureTestUtil; 51 52using tcu::Sampler; 53 54struct SupportedExtensions 55{ 56 bool cubeMapArray; 57 bool sRGBR8; 58}; 59 60static tcu::CubeFace getCubeFaceFromNdx (int ndx) 61{ 62 switch (ndx) 63 { 64 case 0: return tcu::CUBEFACE_POSITIVE_X; 65 case 1: return tcu::CUBEFACE_NEGATIVE_X; 66 case 2: return tcu::CUBEFACE_POSITIVE_Y; 67 case 3: return tcu::CUBEFACE_NEGATIVE_Y; 68 case 4: return tcu::CUBEFACE_POSITIVE_Z; 69 case 5: return tcu::CUBEFACE_NEGATIVE_Z; 70 default: 71 DE_ASSERT(false); 72 return tcu::CUBEFACE_LAST; 73 } 74} 75 76namespace 77{ 78 79SupportedExtensions checkSupport (const glu::ContextInfo& renderCtxInfoid) 80{ 81 SupportedExtensions supportedExtensions; 82 83 supportedExtensions.cubeMapArray = renderCtxInfoid.isExtensionSupported("GL_EXT_texture_cube_map_array"); 84 supportedExtensions.sRGBR8 = renderCtxInfoid.isExtensionSupported("GL_EXT_texture_sRGB_R8"); 85 86 return supportedExtensions; 87} 88 89} // anonymous 90 91// TextureCubeArrayFormatCase 92 93class TextureCubeArrayFormatCase : public tcu::TestCase 94{ 95public: 96 TextureCubeArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, deUint32 format, deUint32 dataType, int size, int depth); 97 TextureCubeArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, deUint32 internalFormat, int size, int depth); 98 ~TextureCubeArrayFormatCase (void); 99 100 void init (void); 101 void deinit (void); 102 IterateResult iterate (void); 103 104private: 105 TextureCubeArrayFormatCase (const TextureCubeArrayFormatCase& other); 106 TextureCubeArrayFormatCase& operator= (const TextureCubeArrayFormatCase& other); 107 108 bool testLayerFace (int layerNdx); 109 110 glu::RenderContext& m_renderCtx; 111 const glu::ContextInfo& m_renderCtxInfo; 112 113 const deUint32 m_format; 114 const deUint32 m_dataType; 115 const int m_size; 116 const int m_depth; 117 118 glu::TextureCubeArray* m_texture; 119 TextureTestUtil::TextureRenderer m_renderer; 120 121 int m_curLayerFace; 122}; 123 124TextureCubeArrayFormatCase::TextureCubeArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, deUint32 format, deUint32 dataType, int size, int depth) 125 : TestCase (testCtx, name, description) 126 , m_renderCtx (renderCtx) 127 , m_renderCtxInfo (renderCtxInfo) 128 , m_format (format) 129 , m_dataType (dataType) 130 , m_size (size) 131 , m_depth (depth) 132 , m_texture (DE_NULL) 133 , m_renderer (renderCtx, testCtx.getLog(), glu::getContextTypeGLSLVersion(renderCtx.getType()), glu::PRECISION_HIGHP) 134 , m_curLayerFace (0) 135{ 136} 137 138TextureCubeArrayFormatCase::TextureCubeArrayFormatCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& renderCtxInfo, const char* name, const char* description, deUint32 internalFormat, int size, int depth) 139 : TestCase (testCtx, name, description) 140 , m_renderCtx (renderCtx) 141 , m_renderCtxInfo (renderCtxInfo) 142 , m_format (internalFormat) 143 , m_dataType (GL_NONE) 144 , m_size (size) 145 , m_depth (depth) 146 , m_texture (DE_NULL) 147 , m_renderer (renderCtx, testCtx.getLog(), glu::getContextTypeGLSLVersion(renderCtx.getType()), glu::PRECISION_HIGHP) 148 , m_curLayerFace (0) 149{ 150} 151 152TextureCubeArrayFormatCase::~TextureCubeArrayFormatCase (void) 153{ 154 deinit(); 155} 156 157void TextureCubeArrayFormatCase::init (void) 158{ 159 const SupportedExtensions supportedExtensions = checkSupport(m_renderCtxInfo); 160 161 if ((supportedExtensions.cubeMapArray && m_format != GL_SR8_EXT) || 162 (supportedExtensions.cubeMapArray && m_format == GL_SR8_EXT && supportedExtensions.sRGBR8)) 163 { 164 m_texture = m_dataType != GL_NONE 165 ? new glu::TextureCubeArray(m_renderCtx, m_format, m_dataType, m_size, m_depth) // Implicit internal format. 166 : new glu::TextureCubeArray(m_renderCtx, m_format, m_size, m_depth); // Explicit internal format. 167 168 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 169 170 // Fill level 0. 171 m_texture->getRefTexture().allocLevel(0); 172 tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax); 173 174 // Initialize state. 175 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 176 m_curLayerFace = 0; 177 } 178 else 179 { 180 if (supportedExtensions.cubeMapArray == false) 181 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Cube map arrays not supported"); 182 183 if (supportedExtensions.sRGBR8 == false) 184 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "texture srgb r8 not supported"); 185 } 186} 187 188void TextureCubeArrayFormatCase::deinit (void) 189{ 190 delete m_texture; 191 m_texture = DE_NULL; 192 193 m_renderer.clear(); 194} 195 196bool TextureCubeArrayFormatCase::testLayerFace (int layerFaceNdx) 197{ 198 const glw::Functions& gl = m_renderCtx.getFunctions(); 199 TestLog& log = m_testCtx.getLog(); 200 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_size, m_size, deStringHash(getName())); 201 tcu::Surface renderedFrame (viewport.width, viewport.height); 202 tcu::Surface referenceFrame (viewport.width, viewport.height); 203 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 204 vector<float> texCoord; 205 ReferenceParams renderParams (TEXTURETYPE_CUBE_ARRAY); 206 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat()); 207 const int layerNdx = layerFaceNdx / 6; 208 const tcu::CubeFace face = getCubeFaceFromNdx(layerFaceNdx % 6); 209 210 renderParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); 211 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST, Sampler::NEAREST); 212 renderParams.sampler.seamlessCubeMap = true; 213 renderParams.colorScale = spec.lookupScale; 214 renderParams.colorBias = spec.lookupBias; 215 216 // Layer here specifies the cube slice 217 computeQuadTexCoordCubeArray(texCoord, face, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f), tcu::Vec2((float)layerNdx)); 218 219 // Setup base viewport. 220 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 221 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 222 223 // Upload texture data to GL. 224 m_texture->upload(); 225 226 // Bind to unit 0. 227 gl.activeTexture(GL_TEXTURE0); 228 gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, m_texture->getGLTexture()); 229 230 // Setup nearest neighbor filtering and clamp-to-edge. 231 gl.texParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 232 gl.texParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 233 gl.texParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 234 gl.texParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 235 236 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 237 238 // Draw. 239 m_renderer.renderQuad(0, &texCoord[0], renderParams); 240 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 241 242 // Compute reference. 243 sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), m_texture->getRefTexture(), &texCoord[0], renderParams); 244 245 // Compare and log. 246 return compareImages(log, (string("LayerFace" + de::toString(layerFaceNdx))).c_str(), (string("Layer-face " + de::toString(layerFaceNdx))).c_str(), referenceFrame, renderedFrame, threshold); 247} 248 249TextureCubeArrayFormatCase::IterateResult TextureCubeArrayFormatCase::iterate (void) 250{ 251 if (m_testCtx.getTestResult() == QP_TEST_RESULT_NOT_SUPPORTED) 252 return STOP; 253 254 // Execute test for all layers. 255 bool isOk = testLayerFace(m_curLayerFace); 256 257 if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 258 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 259 260 m_curLayerFace += 1; 261 262 return m_curLayerFace < m_texture->getRefTexture().getDepth() ? CONTINUE : STOP; 263} 264 265// TextureBufferFormatCase 266 267class TextureBufferFormatCase : public TestCase 268{ 269public: 270 TextureBufferFormatCase (Context& ctx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width); 271 ~TextureBufferFormatCase (void); 272 273 void init (void); 274 void deinit (void); 275 IterateResult iterate (void); 276 277private: 278 TextureBufferFormatCase (const TextureBufferFormatCase& other); 279 TextureBufferFormatCase& operator= (const TextureBufferFormatCase& other); 280 281 glu::RenderContext& m_renderCtx; 282 283 deUint32 m_format; 284 int m_width; 285 int m_maxTextureBufferSize; 286 287 glu::TextureBuffer* m_texture; 288 TextureRenderer m_renderer; 289}; 290 291TextureBufferFormatCase::TextureBufferFormatCase (Context& ctx, glu::RenderContext& renderCtx, const char* name, const char* description, deUint32 internalFormat, int width) 292 : TestCase (ctx, name, description) 293 , m_renderCtx (renderCtx) 294 , m_format (internalFormat) 295 , m_width (width) 296 , m_maxTextureBufferSize (0) 297 , m_texture (DE_NULL) 298 , m_renderer (renderCtx, ctx.getTestContext().getLog(), glu::getContextTypeGLSLVersion(renderCtx.getType()), glu::PRECISION_HIGHP) 299{ 300} 301 302TextureBufferFormatCase::~TextureBufferFormatCase (void) 303{ 304 deinit(); 305} 306 307void TextureBufferFormatCase::init (void) 308{ 309 TestLog& log = m_testCtx.getLog(); 310 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_format); 311 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(fmt); 312 tcu::Vec4 colorA (spec.valueMin.x(), spec.valueMax.y(), spec.valueMin.z(), spec.valueMax.w()); 313 tcu::Vec4 colorB (spec.valueMax.x(), spec.valueMin.y(), spec.valueMax.z(), spec.valueMin.w()); 314 const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)); 315 316 if (!supportsES32 317 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_buffer") 318 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_buffer")) 319 { 320 TCU_THROW(NotSupportedError, "Texture buffers not supported"); 321 } 322 323 m_maxTextureBufferSize = m_context.getContextInfo().getInt(GL_MAX_TEXTURE_BUFFER_SIZE); 324 325 if (m_maxTextureBufferSize <= 0) 326 TCU_THROW(NotSupportedError, "GL_MAX_TEXTURE_BUFFER_SIZE > 0 required"); 327 328 log << TestLog::Message << "Buffer texture, " << glu::getTextureFormatStr(m_format) << ", " << m_width 329 << ",\n fill with " << formatGradient(&colorA, &colorB) << " gradient" 330 << TestLog::EndMessage; 331 332 m_texture = new glu::TextureBuffer(m_renderCtx, m_format, m_width * fmt.getPixelSize()); 333 334 // Fill level 0. 335 tcu::fillWithComponentGradients(m_texture->getFullRefTexture(), colorA, colorB); 336} 337 338void TextureBufferFormatCase::deinit (void) 339{ 340 delete m_texture; 341 m_texture = DE_NULL; 342 343 m_renderer.clear(); 344} 345 346TextureBufferFormatCase::IterateResult TextureBufferFormatCase::iterate (void) 347{ 348 TestLog& log = m_testCtx.getLog(); 349 const glw::Functions& gl = m_renderCtx.getFunctions(); 350 RandomViewport viewport (m_renderCtx.getRenderTarget(), m_width, 1, deStringHash(getName())); 351 tcu::Surface renderedFrame (viewport.width, viewport.height); 352 tcu::Surface referenceFrame (viewport.width, viewport.height); 353 tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 354 vector<float> texCoord; 355 RenderParams renderParams (TEXTURETYPE_BUFFER); 356 const tcu::ConstPixelBufferAccess effectiveRefTexture = glu::getTextureBufferEffectiveRefTexture(*m_texture, m_maxTextureBufferSize); 357 tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(effectiveRefTexture.getFormat()); 358 359 renderParams.flags |= RenderParams::LOG_ALL; 360 renderParams.samplerType = getFetchSamplerType(effectiveRefTexture.getFormat()); 361 renderParams.colorScale = spec.lookupScale; 362 renderParams.colorBias = spec.lookupBias; 363 364 computeQuadTexCoord1D(texCoord, 0.0f, (float)(effectiveRefTexture.getWidth())); 365 366 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 367 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 368 369 // Setup base viewport. 370 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 371 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 372 373 // Upload texture data to GL. 374 m_texture->upload(); 375 376 // Bind to unit 0. 377 gl.activeTexture(GL_TEXTURE0); 378 gl.bindTexture(GL_TEXTURE_BUFFER, m_texture->getGLTexture()); 379 380 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); 381 382 // Draw. 383 m_renderer.renderQuad(0, &texCoord[0], renderParams); 384 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 385 386 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); 387 388 // Compute reference. 389 fetchTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat()), effectiveRefTexture, &texCoord[0], spec.lookupScale, spec.lookupBias); 390 391 // Compare and log. 392 bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold); 393 394 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 395 isOk ? "Pass" : "Image comparison failed"); 396 397 return STOP; 398} 399 400// TextureFormatTests 401 402TextureFormatTests::TextureFormatTests (Context& context) 403 : TestCaseGroup(context, "format", "Texture Format Tests") 404{ 405} 406 407TextureFormatTests::~TextureFormatTests (void) 408{ 409} 410 411vector<string> toStringVector (const char* const* str, int numStr) 412{ 413 vector<string> v; 414 v.resize(numStr); 415 for (int i = 0; i < numStr; i++) 416 v[i] = str[i]; 417 return v; 418} 419 420void TextureFormatTests::init (void) 421{ 422 tcu::TestCaseGroup* unsizedGroup = DE_NULL; 423 tcu::TestCaseGroup* sizedGroup = DE_NULL; 424 tcu::TestCaseGroup* sizedBufferGroup = DE_NULL; 425 addChild((unsizedGroup = new tcu::TestCaseGroup(m_testCtx, "unsized", "Unsized formats"))); 426 addChild((sizedGroup = new tcu::TestCaseGroup(m_testCtx, "sized", "Sized formats"))); 427 addChild((sizedBufferGroup = new tcu::TestCaseGroup(m_testCtx, "buffer", "Sized formats (Buffer)"))); 428 429 tcu::TestCaseGroup* sizedCubeArrayGroup = DE_NULL; 430 sizedGroup->addChild((sizedCubeArrayGroup = new tcu::TestCaseGroup(m_testCtx, "cube_array", "Sized formats (2D Array)"))); 431 432 struct 433 { 434 const char* name; 435 deUint32 format; 436 deUint32 dataType; 437 } texFormats[] = 438 { 439 { "alpha", GL_ALPHA, GL_UNSIGNED_BYTE }, 440 { "luminance", GL_LUMINANCE, GL_UNSIGNED_BYTE }, 441 { "luminance_alpha", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE }, 442 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 }, 443 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE }, 444 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 }, 445 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 }, 446 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE } 447 }; 448 449 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(texFormats); formatNdx++) 450 { 451 deUint32 format = texFormats[formatNdx].format; 452 deUint32 dataType = texFormats[formatNdx].dataType; 453 string nameBase = texFormats[formatNdx].name; 454 string descriptionBase = string(glu::getTextureFormatName(format)) + ", " + glu::getTypeName(dataType); 455 456 unsizedGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_array_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), format, dataType, 64, 12)); 457 unsizedGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_cube_array_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), format, dataType, 64, 12)); 458 } 459 460 struct 461 { 462 const char* name; 463 deUint32 internalFormat; 464 } sizedColorFormats[] = 465 { 466 { "rgba32f", GL_RGBA32F, }, 467 { "rgba32i", GL_RGBA32I, }, 468 { "rgba32ui", GL_RGBA32UI, }, 469 { "rgba16f", GL_RGBA16F, }, 470 { "rgba16i", GL_RGBA16I, }, 471 { "rgba16ui", GL_RGBA16UI, }, 472 { "rgba8", GL_RGBA8, }, 473 { "rgba8i", GL_RGBA8I, }, 474 { "rgba8ui", GL_RGBA8UI, }, 475 { "srgb_r8", GL_SR8_EXT, }, 476 { "srgb8_alpha8", GL_SRGB8_ALPHA8, }, 477 { "rgb10_a2", GL_RGB10_A2, }, 478 { "rgb10_a2ui", GL_RGB10_A2UI, }, 479 { "rgba4", GL_RGBA4, }, 480 { "rgb5_a1", GL_RGB5_A1, }, 481 { "rgba8_snorm", GL_RGBA8_SNORM, }, 482 { "rgb8", GL_RGB8, }, 483 { "rgb565", GL_RGB565, }, 484 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, }, 485 { "rgb32f", GL_RGB32F, }, 486 { "rgb32i", GL_RGB32I, }, 487 { "rgb32ui", GL_RGB32UI, }, 488 { "rgb16f", GL_RGB16F, }, 489 { "rgb16i", GL_RGB16I, }, 490 { "rgb16ui", GL_RGB16UI, }, 491 { "rgb8_snorm", GL_RGB8_SNORM, }, 492 { "rgb8i", GL_RGB8I, }, 493 { "rgb8ui", GL_RGB8UI, }, 494 { "srgb8", GL_SRGB8, }, 495 { "rgb9_e5", GL_RGB9_E5, }, 496 { "rg32f", GL_RG32F, }, 497 { "rg32i", GL_RG32I, }, 498 { "rg32ui", GL_RG32UI, }, 499 { "rg16f", GL_RG16F, }, 500 { "rg16i", GL_RG16I, }, 501 { "rg16ui", GL_RG16UI, }, 502 { "rg8", GL_RG8, }, 503 { "rg8i", GL_RG8I, }, 504 { "rg8ui", GL_RG8UI, }, 505 { "rg8_snorm", GL_RG8_SNORM, }, 506 { "r32f", GL_R32F, }, 507 { "r32i", GL_R32I, }, 508 { "r32ui", GL_R32UI, }, 509 { "r16f", GL_R16F, }, 510 { "r16i", GL_R16I, }, 511 { "r16ui", GL_R16UI, }, 512 { "r8", GL_R8, }, 513 { "r8i", GL_R8I, }, 514 { "r8ui", GL_R8UI, }, 515 { "r8_snorm", GL_R8_SNORM, } 516 }; 517 518 struct 519 { 520 const char* name; 521 deUint32 internalFormat; 522 } sizedDepthStencilFormats[] = 523 { 524 // Depth and stencil formats 525 { "depth_component32f", GL_DEPTH_COMPONENT32F }, 526 { "depth_component24", GL_DEPTH_COMPONENT24 }, 527 { "depth_component16", GL_DEPTH_COMPONENT16 }, 528 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 }, 529 { "depth24_stencil8", GL_DEPTH24_STENCIL8 } 530 }; 531 532 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedColorFormats); formatNdx++) 533 { 534 deUint32 internalFormat = sizedColorFormats[formatNdx].internalFormat; 535 string nameBase = sizedColorFormats[formatNdx].name; 536 string descriptionBase = glu::getTextureFormatName(internalFormat); 537 538 sizedCubeArrayGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), internalFormat, 64, 12)); 539 sizedCubeArrayGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), internalFormat, 64, 12)); 540 } 541 542 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(sizedDepthStencilFormats); formatNdx++) 543 { 544 deUint32 internalFormat = sizedDepthStencilFormats[formatNdx].internalFormat; 545 string nameBase = sizedDepthStencilFormats[formatNdx].name; 546 string descriptionBase = glu::getTextureFormatName(internalFormat); 547 548 sizedCubeArrayGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), internalFormat, 64, 12)); 549 sizedCubeArrayGroup->addChild(new TextureCubeArrayFormatCase (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_CUBE_MAP_ARRAY").c_str(), internalFormat, 64, 12)); 550 } 551 552 // \todo Check 553 struct 554 { 555 const char* name; 556 deUint32 internalFormat; 557 } bufferColorFormats[] = 558 { 559 { "r8", GL_R8, }, 560 { "r16f", GL_R16F, }, 561 { "r32f", GL_R32F, }, 562 { "r8i", GL_R8I, }, 563 { "r16i", GL_R16I, }, 564 { "r32i", GL_R32I, }, 565 { "r8ui", GL_R8UI, }, 566 { "r16ui", GL_R16UI, }, 567 { "r32ui", GL_R32UI, }, 568 { "rg8", GL_RG8, }, 569 { "rg16f", GL_RG16F, }, 570 { "rg32f", GL_RG32F, }, 571 { "rg8i", GL_RG8I, }, 572 { "rg16i", GL_RG16I, }, 573 { "rg32i", GL_RG32I, }, 574 { "rg8ui", GL_RG8UI, }, 575 { "rg16ui", GL_RG16UI, }, 576 { "rg32ui", GL_RG32UI, }, 577 { "rgba8", GL_RGBA8, }, 578 { "rgba16f", GL_RGBA16F, }, 579 { "rgba32f", GL_RGBA32F, }, 580 { "rgba8i", GL_RGBA8I, }, 581 { "rgba16i", GL_RGBA16I, }, 582 { "rgba32i", GL_RGBA32I, }, 583 { "rgba8ui", GL_RGBA8UI, }, 584 { "rgba16ui", GL_RGBA16UI, }, 585 { "rgba32ui", GL_RGBA32UI, } 586 }; 587 588 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(bufferColorFormats); formatNdx++) 589 { 590 deUint32 internalFormat = bufferColorFormats[formatNdx].internalFormat; 591 string nameBase = bufferColorFormats[formatNdx].name; 592 string descriptionBase = glu::getTextureFormatName(internalFormat); 593 594 sizedBufferGroup->addChild (new TextureBufferFormatCase (m_context, m_context.getRenderContext(), (nameBase + "_pot").c_str(), (descriptionBase + ", GL_TEXTURE_BUFFER").c_str(), internalFormat, 64)); 595 sizedBufferGroup->addChild (new TextureBufferFormatCase (m_context, m_context.getRenderContext(), (nameBase + "_npot").c_str(), (descriptionBase + ", GL_TEXTURE_BUFFER").c_str(), internalFormat, 112)); 596 } 597} 598 599} // Functional 600} // gles31 601} // deqp 602