1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) 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 Framebuffer completeness tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fFboCompletenessTests.hpp" 25 26 #include "glsFboCompletenessTests.hpp" 27 #include <sstream> 28 29 using namespace glw; 30 using deqp::gls::Range; 31 using namespace deqp::gls::FboUtil; 32 using namespace deqp::gls::FboUtil::config; 33 namespace fboc = deqp::gls::fboc; 34 typedef tcu::TestCase::IterateResult IterateResult; 35 using std::string; 36 using std::ostringstream; 37 38 namespace deqp 39 { 40 namespace gles3 41 { 42 namespace Functional 43 { 44 45 static const FormatKey s_es3ColorRenderables[] = 46 { 47 // GLES3, 4.4.4: "An internal format is color-renderable if it is one of 48 // the formats from table 3.12 noted as color-renderable..." 49 GL_R8, GL_RG8, GL_RGB8, GL_RGB565, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, 50 GL_RGB10_A2, GL_RGB10_A2UI, GL_SRGB8_ALPHA8, 51 GL_R8I, GL_R8UI, GL_R16I, GL_R16UI, GL_R32I, GL_R32UI, 52 GL_RG8I, GL_RG8UI, GL_RG16I, GL_RG16UI, GL_RG32I, GL_RG32UI, 53 GL_RGBA8I, GL_RGBA8UI, GL_RGBA16I, GL_RGBA16UI, GL_RGBA32I, GL_RGBA32UI, 54 }; 55 56 static const FormatKey s_es3UnsizedColorRenderables[] = 57 { 58 // "...or if it is unsized format RGBA or RGB." 59 // See Table 3.3 in GLES3. 60 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_BYTE), 61 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4), 62 GLS_UNSIZED_FORMATKEY(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1), 63 GLS_UNSIZED_FORMATKEY(GL_RGB, GL_UNSIGNED_BYTE), 64 GLS_UNSIZED_FORMATKEY(GL_RGB, GL_UNSIGNED_SHORT_5_6_5), 65 }; 66 67 static const FormatKey s_es3DepthRenderables[] = 68 { 69 // GLES3, 4.4.4: "An internal format is depth-renderable if it is one of 70 // the formats from table 3.13." 71 GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32F, 72 GL_DEPTH24_STENCIL8, GL_DEPTH32F_STENCIL8, 73 }; 74 75 static const FormatKey s_es3StencilRboRenderables[] = 76 { 77 // GLES3, 4.4.4: "An internal format is stencil-renderable if it is 78 // STENCIL_INDEX8..." 79 GL_STENCIL_INDEX8, 80 }; 81 82 static const FormatKey s_es3StencilRenderables[] = 83 { 84 // "...or one of the formats from table 3.13 whose base internal format is 85 // DEPTH_STENCIL." 86 GL_DEPTH24_STENCIL8, GL_DEPTH32F_STENCIL8, 87 }; 88 89 static const FormatKey s_es3TextureFloatFormats[] = 90 { 91 GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F, 92 GL_RG32F, GL_RG16F, GL_R32F, GL_R16F, 93 GL_RGBA16F, GL_RGB16F, GL_RG16F, GL_R16F, 94 }; 95 96 static const FormatKey s_es3NotRenderableTextureFormats[] = 97 { 98 GL_R8_SNORM, GL_RG8_SNORM, GL_RGB8_SNORM, GL_RGBA8_SNORM, 99 GL_RGB9_E5, GL_SRGB8, 100 GL_RGB8I, GL_RGB16I, GL_RGB32I, 101 GL_RGB8UI, GL_RGB16UI,GL_RGB32UI, 102 }; 103 104 static const FormatEntry s_es3Formats[] = 105 { 106 // Renderbuffers don't support unsized formats 107 { REQUIRED_RENDERABLE | COLOR_RENDERABLE | TEXTURE_VALID, 108 GLS_ARRAY_RANGE(s_es3UnsizedColorRenderables) }, 109 { REQUIRED_RENDERABLE | COLOR_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID, 110 GLS_ARRAY_RANGE(s_es3ColorRenderables) }, 111 { REQUIRED_RENDERABLE | DEPTH_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID, 112 GLS_ARRAY_RANGE(s_es3DepthRenderables) }, 113 { REQUIRED_RENDERABLE | STENCIL_RENDERABLE | RENDERBUFFER_VALID, 114 GLS_ARRAY_RANGE(s_es3StencilRboRenderables) }, 115 { REQUIRED_RENDERABLE | STENCIL_RENDERABLE | RENDERBUFFER_VALID | TEXTURE_VALID, 116 GLS_ARRAY_RANGE(s_es3StencilRenderables) }, 117 { TEXTURE_VALID, 118 GLS_ARRAY_RANGE(s_es3NotRenderableTextureFormats) }, 119 120 // These are not color-renderable in vanilla ES3, but we need to mark them 121 // as valid for textures, since EXT_color_buffer_(half_)float brings in 122 // color-renderability and only renderbuffer-validity. 123 { TEXTURE_VALID, 124 GLS_ARRAY_RANGE(s_es3TextureFloatFormats) }, 125 }; 126 127 // GL_EXT_color_buffer_float 128 static const FormatKey s_extColorBufferFloatFormats[] = 129 { 130 GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F, GL_RG32F, GL_RG16F, GL_R32F, GL_R16F, 131 }; 132 133 // GL_OES_texture_stencil8 134 static const FormatKey s_extOESTextureStencil8[] = 135 { 136 GL_STENCIL_INDEX8, 137 }; 138 139 // GL_EXT_render_snorm 140 static const FormatKey s_extRenderSnorm[] = 141 { 142 GL_R8_SNORM, GL_RG8_SNORM, GL_RGBA8_SNORM, 143 }; 144 145 static const FormatExtEntry s_es3ExtFormats[] = 146 { 147 { 148 "GL_EXT_color_buffer_float", 149 // These are already texture-valid in ES3, the extension just adds RBO 150 // support and makes them color-renderable. 151 (deUint32)(REQUIRED_RENDERABLE | COLOR_RENDERABLE | RENDERBUFFER_VALID), 152 GLS_ARRAY_RANGE(s_extColorBufferFloatFormats) 153 }, 154 { 155 "GL_OES_texture_stencil8", 156 // \note: es3 RBO tests actually cover the first two requirements 157 // - kept here for completeness 158 (deUint32)(REQUIRED_RENDERABLE | STENCIL_RENDERABLE | TEXTURE_VALID), 159 GLS_ARRAY_RANGE(s_extOESTextureStencil8) 160 }, 161 162 // Since GLES31 is backwards compatible to GLES3, we might actually be running on a GLES31. 163 // Add rule changes of GLES31 that have no corresponding GLES3 extension. 164 // 165 // \note Not all feature changes are listed here but only those that alter GLES3 subset of 166 // the formats 167 { 168 "DEQP_gles31_core_compatible GL_EXT_render_snorm", 169 (deUint32)(REQUIRED_RENDERABLE | COLOR_RENDERABLE | TEXTURE_VALID | RENDERBUFFER_VALID), 170 GLS_ARRAY_RANGE(s_extRenderSnorm) 171 }, 172 }; 173 174 class ES3Checker : public Checker 175 { 176 public: 177 ES3Checker (const glu::RenderContext& ctx) 178 : Checker (ctx) 179 , m_numSamples (-1) 180 , m_depthStencilImage (0) 181 , m_depthStencilType (GL_NONE) {} 182 void check (GLenum attPoint, const Attachment& att, const Image* image); 183 184 private: 185 //! The common number of samples of images. 186 GLsizei m_numSamples; 187 188 //! The common image for depth and stencil attachments. 189 GLuint m_depthStencilImage; 190 GLenum m_depthStencilType; 191 }; 192 193 void ES3Checker::check (GLenum attPoint, const Attachment& att, const Image* image) 194 { 195 GLsizei imgSamples = imageNumSamples(*image); 196 197 if (m_numSamples == -1) 198 { 199 m_numSamples = imgSamples; 200 } 201 else 202 { 203 // GLES3: "The value of RENDERBUFFER_SAMPLES is the same for all attached 204 // renderbuffers and, if the attached images are a mix of renderbuffers 205 // and textures, the value of RENDERBUFFER_SAMPLES is zero." 206 // 207 // On creating a renderbuffer: "If _samples_ is zero, then 208 // RENDERBUFFER_SAMPLES is set to zero. Otherwise [...] the resulting 209 // value for RENDERBUFFER_SAMPLES is guaranteed to be greater than or 210 // equal to _samples_ and no more than the next larger sample count 211 // supported by the implementation." 212 213 // Either all attachments are zero-sample renderbuffers and/or 214 // textures, or none of them are. 215 if ((m_numSamples == 0) != (imgSamples == 0)) 216 addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, "Mixed multi- and single-sampled attachments"); 217 218 // If the attachments requested a different number of samples, the 219 // implementation is allowed to report this as incomplete. However, it 220 // is also possible that despite the different requests, the 221 // implementation allocated the same number of samples to both. Hence 222 // reporting the framebuffer as complete is also legal. 223 if (m_numSamples != imgSamples) 224 addPotentialFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, "Number of samples differ"); 225 } 226 227 // "Depth and stencil attachments, if present, are the same image." 228 if (attPoint == GL_DEPTH_ATTACHMENT || attPoint == GL_STENCIL_ATTACHMENT) 229 { 230 if (m_depthStencilImage == 0) 231 { 232 m_depthStencilImage = att.imageName; 233 m_depthStencilType = attachmentType(att); 234 } 235 else 236 { 237 if (m_depthStencilImage != att.imageName || m_depthStencilType != attachmentType(att)) 238 addFBOStatus(GL_FRAMEBUFFER_UNSUPPORTED, "Depth and stencil attachments are not the same image"); 239 } 240 } 241 } 242 243 struct NumLayersParams 244 { 245 GLenum textureKind; //< GL_TEXTURE_3D or GL_TEXTURE_2D_ARRAY 246 GLsizei numLayers; //< Number of layers in texture 247 GLsizei attachmentLayer; //< Layer referenced by attachment 248 249 static string getName (const NumLayersParams& params); 250 static string getDescription (const NumLayersParams& params); 251 }; 252 253 string NumLayersParams::getName (const NumLayersParams& params) 254 { 255 ostringstream os; 256 const string kindStr = params.textureKind == GL_TEXTURE_3D ? "3d" : "2darr"; 257 os << kindStr << "_" << params.numLayers << "_" << params.attachmentLayer; 258 return os.str(); 259 } 260 261 string NumLayersParams::getDescription (const NumLayersParams& params) 262 { 263 ostringstream os; 264 const string kindStr = (params.textureKind == GL_TEXTURE_3D 265 ? "3D Texture" 266 : "2D Array Texture"); 267 os << kindStr + ", " 268 << params.numLayers << " layers, " 269 << "attached layer " << params.attachmentLayer << "."; 270 return os.str(); 271 } 272 273 class NumLayersTest : public fboc::ParamTest<NumLayersParams> 274 { 275 public: 276 NumLayersTest (fboc::Context& ctx, NumLayersParams param) 277 : fboc::ParamTest<NumLayersParams> (ctx, param) {} 278 279 IterateResult build (FboBuilder& builder); 280 }; 281 282 IterateResult NumLayersTest::build (FboBuilder& builder) 283 { 284 TextureLayered* texCfg = DE_NULL; 285 const GLenum target = GL_COLOR_ATTACHMENT0; 286 287 switch (m_params.textureKind) 288 { 289 case GL_TEXTURE_3D: 290 texCfg = &builder.makeConfig<Texture3D>(); 291 break; 292 case GL_TEXTURE_2D_ARRAY: 293 texCfg = &builder.makeConfig<Texture2DArray>(); 294 break; 295 default: 296 DE_FATAL("Impossible case"); 297 } 298 texCfg->internalFormat = getDefaultFormat(target, GL_TEXTURE); 299 texCfg->width = 64; 300 texCfg->height = 64; 301 texCfg->numLayers = m_params.numLayers; 302 const GLuint tex = builder.glCreateTexture(*texCfg); 303 304 TextureLayerAttachment* att = &builder.makeConfig<TextureLayerAttachment>(); 305 att->layer = m_params.attachmentLayer; 306 att->imageName = tex; 307 308 builder.glAttach(target, att); 309 310 return STOP; 311 } 312 313 enum 314 { 315 SAMPLES_NONE = -2, 316 SAMPLES_TEXTURE = -1 317 }; 318 struct NumSamplesParams 319 { 320 // >= 0: renderbuffer with N samples, -1: texture, -2: no attachment 321 GLsizei numSamples[3]; 322 323 static string getName (const NumSamplesParams& params); 324 static string getDescription (const NumSamplesParams& params); 325 }; 326 327 string NumSamplesParams::getName (const NumSamplesParams& params) 328 { 329 ostringstream os; 330 bool first = true; 331 for (const GLsizei* ns = DE_ARRAY_BEGIN(params.numSamples); 332 ns != DE_ARRAY_END(params.numSamples); 333 ns++) 334 { 335 if (first) 336 first = false; 337 else 338 os << "_"; 339 340 if (*ns == SAMPLES_NONE) 341 os << "none"; 342 else if (*ns == SAMPLES_TEXTURE) 343 os << "tex"; 344 else 345 os << "rbo" << *ns; 346 } 347 return os.str(); 348 } 349 350 string NumSamplesParams::getDescription (const NumSamplesParams& params) 351 { 352 ostringstream os; 353 bool first = true; 354 static const char* const s_names[] = { "color", "depth", "stencil" }; 355 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == DE_LENGTH_OF_ARRAY(params.numSamples)); 356 357 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_names); i++) 358 { 359 GLsizei ns = params.numSamples[i]; 360 361 if (ns == SAMPLES_NONE) 362 continue; 363 364 if (first) 365 first = false; 366 else 367 os << ", "; 368 369 if (ns == SAMPLES_TEXTURE) 370 os << "texture " << s_names[i] << " attachment"; 371 else 372 os << ns << "-sample renderbuffer " << s_names[i] << " attachment"; 373 } 374 return os.str(); 375 } 376 377 class NumSamplesTest : public fboc::ParamTest<NumSamplesParams> 378 { 379 public: 380 NumSamplesTest (fboc::Context& ctx, NumSamplesParams param) 381 : fboc::ParamTest<NumSamplesParams> (ctx, param) {} 382 383 IterateResult build (FboBuilder& builder); 384 }; 385 386 IterateResult NumSamplesTest::build (FboBuilder& builder) 387 { 388 static const GLenum s_targets[] = 389 { 390 GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_DEPTH_ATTACHMENT, 391 }; 392 // Non-integer formats for each attachment type. 393 // \todo [2013-12-17 lauri] Add fixed/floating/integer metadata for formats so 394 // we can pick one smartly or maybe try several. 395 static const GLenum s_formats[] = 396 { 397 GL_RGBA8, GL_RGB565, GL_DEPTH_COMPONENT24, 398 }; 399 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_targets) == DE_LENGTH_OF_ARRAY(m_params.numSamples)); 400 401 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_targets); i++) 402 { 403 const GLenum target = s_targets[i]; 404 const ImageFormat fmt = { s_formats[i], GL_NONE }; 405 406 const GLsizei ns = m_params.numSamples[i]; 407 if (ns == -2) 408 continue; 409 410 if (ns == -1) 411 { 412 attachTargetToNew(target, GL_TEXTURE, fmt, 64, 64, builder); 413 } 414 else 415 { 416 Renderbuffer& rboCfg = builder.makeConfig<Renderbuffer>(); 417 rboCfg.internalFormat = fmt; 418 rboCfg.width = rboCfg.height = 64; 419 rboCfg.numSamples = ns; 420 421 const GLuint rbo = builder.glCreateRbo(rboCfg); 422 // Implementations do not necessarily support sample sizes greater than 1. 423 TCU_CHECK_AND_THROW(NotSupportedError, 424 builder.getError() != GL_INVALID_OPERATION, 425 "Unsupported number of samples"); 426 RenderbufferAttachment& att = builder.makeConfig<RenderbufferAttachment>(); 427 att.imageName = rbo; 428 builder.glAttach(target, &att); 429 } 430 } 431 432 return STOP; 433 } 434 435 class ES3CheckerFactory : public CheckerFactory 436 { 437 public: 438 Checker* createChecker (const glu::RenderContext& ctx) { return new ES3Checker(ctx); } 439 }; 440 441 class TestGroup : public TestCaseGroup 442 { 443 public: 444 TestGroup (Context& context); 445 void init (void); 446 private: 447 ES3CheckerFactory m_checkerFactory; 448 fboc::Context m_fboc; 449 }; 450 451 void TestGroup::init (void) 452 { 453 addChild(m_fboc.createRenderableTests()); 454 addChild(m_fboc.createAttachmentTests()); 455 addChild(m_fboc.createSizeTests()); 456 457 TestCaseGroup* layerTests = new TestCaseGroup( 458 getContext(), "layer", "Tests for layer attachments"); 459 460 static const NumLayersParams s_layersParams[] = 461 { // textureKind numLayers attachmentKind 462 { GL_TEXTURE_2D_ARRAY, 1, 0 }, 463 { GL_TEXTURE_2D_ARRAY, 1, 3 }, 464 { GL_TEXTURE_2D_ARRAY, 4, 3 }, 465 { GL_TEXTURE_2D_ARRAY, 4, 15 }, 466 { GL_TEXTURE_3D, 1, 0 }, 467 { GL_TEXTURE_3D, 1, 15 }, 468 { GL_TEXTURE_3D, 4, 15 }, 469 { GL_TEXTURE_3D, 64, 15 }, 470 }; 471 472 for (const NumLayersParams* lp = DE_ARRAY_BEGIN(s_layersParams); 473 lp != DE_ARRAY_END(s_layersParams); 474 ++lp) 475 layerTests->addChild(new NumLayersTest(m_fboc, *lp)); 476 477 addChild(layerTests); 478 479 TestCaseGroup* sampleTests = new TestCaseGroup( 480 getContext(), "samples", "Tests for multisample attachments"); 481 482 static const NumSamplesParams s_samplesParams[] = 483 { 484 { { 0, SAMPLES_NONE, SAMPLES_NONE } }, 485 { { 1, SAMPLES_NONE, SAMPLES_NONE } }, 486 { { 2, SAMPLES_NONE, SAMPLES_NONE } }, 487 { { 0, SAMPLES_TEXTURE, SAMPLES_NONE } }, 488 { { 1, SAMPLES_TEXTURE, SAMPLES_NONE } }, 489 { { 2, SAMPLES_TEXTURE, SAMPLES_NONE } }, 490 { { 2, 1, SAMPLES_NONE } }, 491 { { 2, 2, SAMPLES_NONE } }, 492 { { 0, 0, SAMPLES_TEXTURE } }, 493 { { 1, 2, 0 } }, 494 { { 2, 2, 0 } }, 495 { { 1, 1, 1 } }, 496 { { 1, 2, 4 } }, 497 }; 498 499 for (const NumSamplesParams* lp = DE_ARRAY_BEGIN(s_samplesParams); 500 lp != DE_ARRAY_END(s_samplesParams); 501 ++lp) 502 sampleTests->addChild(new NumSamplesTest(m_fboc, *lp)); 503 504 addChild(sampleTests); 505 } 506 507 TestGroup::TestGroup (Context& ctx) 508 : TestCaseGroup (ctx, "completeness", "Completeness tests") 509 , m_checkerFactory () 510 , m_fboc (ctx.getTestContext(), ctx.getRenderContext(), m_checkerFactory) 511 { 512 const FormatEntries stdRange = GLS_ARRAY_RANGE(s_es3Formats); 513 const FormatExtEntries extRange = GLS_ARRAY_RANGE(s_es3ExtFormats); 514 515 m_fboc.addFormats(stdRange); 516 m_fboc.addExtFormats(extRange); 517 m_fboc.setHaveMulticolorAtts(true); // Vanilla ES3 has multiple color attachments 518 } 519 520 tcu::TestCaseGroup* createFboCompletenessTests (Context& context) 521 { 522 return new TestGroup(context); 523 } 524 525 } // Functional 526 } // gles3 527 } // deqp 528
