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 Pixel Buffer Object tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fPixelBufferObjectTests.hpp" 25 26 #include "tcuTexture.hpp" 27 #include "tcuTextureUtil.hpp" 28 #include "tcuImageCompare.hpp" 29 #include "tcuTestLog.hpp" 30 #include "tcuRenderTarget.hpp" 31 32 #include "gluTextureUtil.hpp" 33 #include "gluPixelTransfer.hpp" 34 #include "gluShaderProgram.hpp" 35 36 #include "deRandom.hpp" 37 #include "deString.h" 38 39 #include <string> 40 #include <sstream> 41 42 #include "glw.h" 43 44 using std::string; 45 using std::stringstream; 46 47 namespace deqp 48 { 49 namespace gles3 50 { 51 namespace Functional 52 { 53 54 namespace 55 { 56 57 class ReadPixelsTest : public TestCase 58 { 59 public: 60 struct TestSpec 61 { 62 enum FramebufferType 63 { 64 FRAMEBUFFERTYPE_NATIVE = 0, 65 FRAMEBUFFERTYPE_RENDERBUFFER 66 }; 67 68 string name; 69 string description; 70 71 bool useColorClear; 72 bool renderTriangles; 73 74 FramebufferType framebufferType; 75 GLenum renderbufferFormat; 76 }; 77 78 ReadPixelsTest (Context& context, const TestSpec& spec); 79 ~ReadPixelsTest (void); 80 81 void init (void); 82 void deinit (void); 83 84 IterateResult iterate (void); 85 86 private: 87 void renderTriangle (const tcu::Vec3& a, const tcu::Vec3& b, const tcu::Vec3& c); 88 void clearColor (float r, float g, float b, float a); 89 90 de::Random m_random; 91 tcu::TestLog& m_log; 92 glu::ShaderProgram* m_program; 93 94 TestSpec::FramebufferType m_framebuffeType; 95 96 GLenum m_renderbufferFormat; 97 tcu::TextureChannelClass m_texChannelClass; 98 99 bool m_useColorClears; 100 bool m_renderTriangles; 101 102 GLfloat m_colorScale; 103 }; 104 105 106 ReadPixelsTest::ReadPixelsTest (Context& context, const TestSpec& spec) 107 : TestCase (context, spec.name.c_str(), spec.description.c_str()) 108 , m_random (deStringHash(spec.name.c_str())) 109 , m_log (m_testCtx.getLog()) 110 , m_program (NULL) 111 , m_framebuffeType (spec.framebufferType) 112 , m_renderbufferFormat (spec.renderbufferFormat) 113 , m_texChannelClass (tcu::TEXTURECHANNELCLASS_LAST) 114 , m_useColorClears (spec.useColorClear) 115 , m_renderTriangles (spec.renderTriangles) 116 , m_colorScale (1.0f) 117 { 118 119 if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_NATIVE) 120 { 121 m_colorScale = 1.0f; 122 } 123 else if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER) 124 { 125 m_texChannelClass = tcu::getTextureChannelClass(glu::mapGLInternalFormat(spec.renderbufferFormat).type); 126 switch (m_texChannelClass) 127 { 128 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 129 m_colorScale = 1.0f; 130 break; 131 132 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 133 m_colorScale = 100.0f; 134 break; 135 136 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 137 m_colorScale = 100.0f; 138 break; 139 140 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 141 m_colorScale = 100.0f; 142 break; 143 144 default: 145 DE_ASSERT(false); 146 } 147 } 148 else 149 DE_ASSERT(false); 150 } 151 152 ReadPixelsTest::~ReadPixelsTest (void) 153 { 154 } 155 156 void ReadPixelsTest::init (void) 157 { 158 // Check extensions 159 if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER) 160 { 161 bool supported = false; 162 163 if (m_renderbufferFormat == GL_RGBA16F 164 || m_renderbufferFormat == GL_RG16F) 165 { 166 std::istringstream extensions(std::string((const char*)glGetString(GL_EXTENSIONS))); 167 std::string extension; 168 169 while (std::getline(extensions, extension, ' ')) 170 { 171 if (extension=="GL_EXT_color_buffer_half_float") 172 { 173 supported = true; 174 break; 175 } 176 if (extension=="GL_EXT_color_buffer_float") 177 { 178 supported = true; 179 break; 180 } 181 } 182 } 183 else if (m_renderbufferFormat == GL_RGBA32F 184 || m_renderbufferFormat == GL_RG32F 185 || m_renderbufferFormat == GL_R11F_G11F_B10F) 186 { 187 std::istringstream extensions(std::string((const char*)glGetString(GL_EXTENSIONS))); 188 std::string extension; 189 190 while (std::getline(extensions, extension, ' ')) 191 { 192 if (extension=="GL_EXT_color_buffer_float") 193 { 194 supported = true; 195 break; 196 } 197 } 198 } 199 else 200 supported = true; 201 202 if (!supported) 203 throw tcu::NotSupportedError("Renderbuffer format not supported", "", __FILE__, __LINE__); 204 } 205 206 std::string outtype = ""; 207 208 if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_NATIVE) 209 outtype = "vec4"; 210 else if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER) 211 { 212 switch (m_texChannelClass) 213 { 214 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 215 outtype = "vec4"; 216 break; 217 218 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 219 outtype = "ivec4"; 220 break; 221 222 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 223 outtype = "uvec4"; 224 break; 225 226 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 227 outtype = "vec4"; 228 break; 229 230 default: 231 DE_ASSERT(false); 232 } 233 } 234 else 235 DE_ASSERT(false); 236 237 238 const char* vertexShaderSource = 239 "#version 300 es\n" 240 "in mediump vec3 a_position;\n" 241 "in mediump vec4 a_color;\n" 242 "uniform mediump float u_colorScale;\n" 243 "out mediump vec4 v_color;\n" 244 "void main(void)\n" 245 "{\n" 246 "\tgl_Position = vec4(a_position, 1.0);\n" 247 "\tv_color = u_colorScale * a_color;\n" 248 "}"; 249 250 stringstream fragmentShaderSource; 251 252 fragmentShaderSource << 253 "#version 300 es\n" 254 "in mediump vec4 v_color;\n"; 255 256 257 fragmentShaderSource << "layout (location = 0) out mediump " << outtype << " o_color;\n" 258 "void main(void)\n" 259 "{\n" 260 "\to_color = " << outtype << "(v_color);\n" 261 "}"; 262 263 m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource.str())); 264 265 if (!m_program->isOk()) 266 { 267 m_log << *m_program; 268 TCU_FAIL("Failed to compile shader"); 269 } 270 } 271 272 void ReadPixelsTest::deinit (void) 273 { 274 if (m_program) 275 delete m_program; 276 m_program = NULL; 277 } 278 279 void ReadPixelsTest::renderTriangle (const tcu::Vec3& a, const tcu::Vec3& b, const tcu::Vec3& c) 280 { 281 float positions[3*3]; 282 283 positions[0] = a.x(); 284 positions[1] = a.y(); 285 positions[2] = a.z(); 286 287 positions[3] = b.x(); 288 positions[4] = b.y(); 289 positions[5] = b.z(); 290 291 positions[6] = c.x(); 292 positions[7] = c.y(); 293 positions[8] = c.z(); 294 295 float colors[] = { 296 1.0f, 0.0f, 0.0f, 1.0f, 297 0.0f, 1.0f, 0.0f, 1.0f, 298 0.0f, 0.0f, 1.0f, 1.0f 299 }; 300 301 GLU_CHECK_CALL(glUseProgram(m_program->getProgram())); 302 303 GLuint coordLoc = (GLuint)-1; 304 GLuint colorLoc = (GLuint)-1; 305 GLuint colorScaleLoc = (GLuint)-1; 306 307 colorScaleLoc = glGetUniformLocation(m_program->getProgram(), "u_colorScale"); 308 TCU_CHECK(colorScaleLoc != (GLuint)-1); 309 310 GLU_CHECK_CALL(glUniform1f(colorScaleLoc, m_colorScale)); 311 312 coordLoc = glGetAttribLocation(m_program->getProgram(), "a_position"); 313 TCU_CHECK(coordLoc != (GLuint)-1); 314 315 colorLoc = glGetAttribLocation(m_program->getProgram(), "a_color"); 316 TCU_CHECK(colorLoc != (GLuint)-1); 317 318 GLU_CHECK_CALL(glEnableVertexAttribArray(colorLoc)); 319 GLU_CHECK_CALL(glEnableVertexAttribArray(coordLoc)); 320 321 GLU_CHECK_CALL(glVertexAttribPointer(coordLoc, 3, GL_FLOAT, GL_FALSE, 0, positions)); 322 GLU_CHECK_CALL(glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, 0, colors)); 323 324 GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, 3)); 325 326 GLU_CHECK_CALL(glDisableVertexAttribArray(colorLoc)); 327 GLU_CHECK_CALL(glDisableVertexAttribArray(coordLoc)); 328 329 } 330 331 332 void ReadPixelsTest::clearColor (float r, float g, float b, float a) 333 { 334 if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_NATIVE) 335 { 336 GLU_CHECK_CALL(glClearColor(r, g, b, a)); 337 GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); 338 } 339 else if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER) 340 { 341 switch (m_texChannelClass) 342 { 343 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 344 { 345 GLU_CHECK_CALL(glClearColor(r, g, b, a)); 346 GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); 347 break; 348 } 349 350 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 351 { 352 GLint color[4] = { (GLint)r, (GLint)g, (GLint)b, (GLint)a }; 353 354 GLU_CHECK_CALL(glClearBufferiv(GL_COLOR, 0, color)); 355 break; 356 } 357 358 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 359 { 360 GLuint color[4] = { (GLuint)r, (GLuint)g, (GLuint)b, (GLuint)a }; 361 362 GLU_CHECK_CALL(glClearBufferuiv(GL_COLOR, 0, color)); 363 break; 364 } 365 366 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 367 { 368 GLfloat color[4] = { (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a }; 369 370 GLU_CHECK_CALL(glClearBufferfv(GL_COLOR, 0, color)); 371 break; 372 } 373 374 default: 375 DE_ASSERT(false); 376 } 377 } 378 else 379 DE_ASSERT(false); 380 381 } 382 383 TestCase::IterateResult ReadPixelsTest::iterate(void) 384 { 385 int width = m_context.getRenderTarget().getWidth(); 386 int height = m_context.getRenderTarget().getHeight(); 387 388 GLuint framebuffer = 0; 389 GLuint renderbuffer = 0; 390 391 switch (m_framebuffeType) 392 { 393 case TestSpec::FRAMEBUFFERTYPE_NATIVE: 394 GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, framebuffer)); 395 break; 396 397 case TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER: 398 { 399 GLU_CHECK_CALL(glGenFramebuffers(1, &framebuffer)); 400 GLU_CHECK_CALL(glGenRenderbuffers(1, &renderbuffer)); 401 402 GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer)); 403 GLU_CHECK_CALL(glRenderbufferStorage(GL_RENDERBUFFER, m_renderbufferFormat, width, height)); 404 405 GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, framebuffer)); 406 GLU_CHECK_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer)); 407 408 break; 409 } 410 411 default: 412 DE_ASSERT(false); 413 } 414 415 clearColor(m_colorScale * 0.4f, m_colorScale * 1.0f, m_colorScale * 0.5f, m_colorScale * 1.0f); 416 417 if (m_useColorClears) 418 { 419 const int maxClearCount = 10; 420 const int minClearCount = 6; 421 const int minClearSize = 15; 422 423 int clearCount = m_random.getInt(minClearCount, maxClearCount); 424 425 for (int clearNdx = 0; clearNdx < clearCount; clearNdx++) 426 { 427 int clearX = m_random.getInt(0, width - minClearSize); 428 int clearY = m_random.getInt(0, height - minClearSize); 429 430 int clearWidth = m_random.getInt(minClearSize, width - clearX); 431 int clearHeight = m_random.getInt(minClearSize, height - clearY); 432 433 float clearRed = m_colorScale * m_random.getFloat(); 434 float clearGreen = m_colorScale * m_random.getFloat(); 435 float clearBlue = m_colorScale * m_random.getFloat(); 436 float clearAlpha = m_colorScale * (0.5f + 0.5f * m_random.getFloat()); 437 438 GLU_CHECK_CALL(glEnable(GL_SCISSOR_TEST)); 439 GLU_CHECK_CALL(glScissor(clearX, clearY, clearWidth, clearHeight)); 440 441 clearColor(clearRed, clearGreen, clearBlue, clearAlpha); 442 } 443 444 GLU_CHECK_CALL(glDisable(GL_SCISSOR_TEST)); 445 } 446 447 if (m_renderTriangles) 448 { 449 const int minTriangleCount = 4; 450 const int maxTriangleCount = 10; 451 452 int triangleCount = m_random.getInt(minTriangleCount, maxTriangleCount); 453 454 for (int triangleNdx = 0; triangleNdx < triangleCount; triangleNdx++) 455 { 456 float x1 = 2.0f * m_random.getFloat() - 1.0f; 457 float y1 = 2.0f * m_random.getFloat() - 1.0f; 458 float z1 = 2.0f * m_random.getFloat() - 1.0f; 459 460 float x2 = 2.0f * m_random.getFloat() - 1.0f; 461 float y2 = 2.0f * m_random.getFloat() - 1.0f; 462 float z2 = 2.0f * m_random.getFloat() - 1.0f; 463 464 float x3 = 2.0f * m_random.getFloat() - 1.0f; 465 float y3 = 2.0f * m_random.getFloat() - 1.0f; 466 float z3 = 2.0f * m_random.getFloat() - 1.0f; 467 468 renderTriangle(tcu::Vec3(x1, y1, z1), tcu::Vec3(x2, y2, z2), tcu::Vec3(x3, y3, z3)); 469 } 470 } 471 472 tcu::TextureFormat readFormat; 473 GLenum readPixelsFormat; 474 GLenum readPixelsType; 475 bool floatCompare; 476 477 478 if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_NATIVE) 479 { 480 readFormat = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 481 readPixelsFormat = GL_RGBA; 482 readPixelsType = GL_UNSIGNED_BYTE; 483 floatCompare = false; 484 } 485 else if (m_framebuffeType == TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER) 486 { 487 switch (m_texChannelClass) 488 { 489 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 490 readFormat = glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE); 491 readPixelsFormat = GL_RGBA; 492 readPixelsType = GL_UNSIGNED_BYTE; 493 floatCompare = true; 494 break; 495 496 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 497 readFormat = glu::mapGLTransferFormat(GL_RGBA_INTEGER, GL_INT); 498 readPixelsFormat = GL_RGBA_INTEGER; 499 readPixelsType = GL_INT; 500 floatCompare = false; 501 break; 502 503 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 504 readFormat = glu::mapGLTransferFormat(GL_RGBA_INTEGER, GL_UNSIGNED_INT); 505 readPixelsFormat = GL_RGBA_INTEGER; 506 readPixelsType = GL_UNSIGNED_INT; 507 floatCompare = false; 508 break; 509 510 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 511 readFormat = glu::mapGLTransferFormat(GL_RGBA, GL_FLOAT); 512 readPixelsFormat = GL_RGBA; 513 readPixelsType = GL_FLOAT; 514 floatCompare = true; 515 break; 516 517 default: 518 DE_ASSERT(false); 519 // Silence warnings 520 readFormat = glu::mapGLTransferFormat(GL_RGBA, GL_FLOAT); 521 readPixelsFormat = GL_RGBA; 522 readPixelsType = GL_FLOAT; 523 floatCompare = true; 524 } 525 } 526 else 527 { 528 // Silence warnings 529 readFormat = glu::mapGLTransferFormat(GL_RGBA, GL_FLOAT); 530 readPixelsFormat = GL_RGBA; 531 readPixelsType = GL_FLOAT; 532 floatCompare = true; 533 DE_ASSERT(false); 534 } 535 536 tcu::Texture2D readRefrence (readFormat, width, height); 537 const int readDataSize = readRefrence.getWidth() * readRefrence.getHeight() * readFormat.getPixelSize(); 538 539 readRefrence.allocLevel(0); 540 541 GLuint pixelBuffer = (GLuint)-1; 542 543 GLU_CHECK_CALL(glGenBuffers(1, &pixelBuffer)); 544 GLU_CHECK_CALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, pixelBuffer)); 545 GLU_CHECK_CALL(glBufferData(GL_PIXEL_PACK_BUFFER, readDataSize, NULL, GL_STREAM_READ)); 546 547 GLU_CHECK_CALL(glReadPixels(0, 0, width, height, readPixelsFormat, readPixelsType, 0)); 548 549 const deUint8* bufferData = (const deUint8*)glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, readDataSize, GL_MAP_READ_BIT); 550 GLU_CHECK_MSG("glMapBufferRange() failed"); 551 552 tcu::ConstPixelBufferAccess readResult(readFormat, width, height, 1, bufferData); 553 554 GLU_CHECK_CALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); 555 556 GLU_CHECK_CALL(glReadPixels(0, 0, width, height, readPixelsFormat, readPixelsType, readRefrence.getLevel(0).getDataPtr())); 557 558 if (framebuffer) 559 GLU_CHECK_CALL(glDeleteFramebuffers(1, &framebuffer)); 560 561 if (renderbuffer) 562 GLU_CHECK_CALL(glDeleteRenderbuffers(1, &renderbuffer)); 563 564 565 bool isOk = false; 566 567 if (floatCompare) 568 isOk = tcu::floatThresholdCompare(m_log, "Result comparision", "Result of read pixels to memory compared with result of read pixels to buffer", readRefrence.getLevel(0), readResult, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::COMPARE_LOG_RESULT); 569 else 570 isOk = tcu::intThresholdCompare(m_log, "Result comparision", "Result of read pixels to memory compared with result of read pixels to buffer", readRefrence.getLevel(0), readResult, tcu::UVec4(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); 571 572 GLU_CHECK_CALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, pixelBuffer)); 573 GLU_CHECK_CALL(glUnmapBuffer(GL_PIXEL_PACK_BUFFER)); 574 GLU_CHECK_CALL(glDeleteBuffers(1, &pixelBuffer)); 575 576 if (isOk) 577 { 578 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 579 return STOP; 580 } 581 else 582 { 583 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 584 return STOP; 585 } 586 } 587 588 } // anonymous 589 590 PixelBufferObjectTests::PixelBufferObjectTests (Context& context) 591 : TestCaseGroup (context, "pbo", "Pixel buffer objects tests") 592 { 593 } 594 595 PixelBufferObjectTests::~PixelBufferObjectTests (void) 596 { 597 } 598 599 void PixelBufferObjectTests::init (void) 600 { 601 TestCaseGroup* nativeFramebufferGroup = new TestCaseGroup(m_context, "native", "Tests with reading from native framebuffer"); 602 603 ReadPixelsTest::TestSpec nativeFramebufferTests[] = { 604 { 605 "clears", 606 "Simple read pixels test with color clears", 607 true, 608 false, 609 ReadPixelsTest::TestSpec::FRAMEBUFFERTYPE_NATIVE, 610 GL_NONE 611 }, 612 { 613 "triangles", 614 "Simple read pixels test rendering triangles", 615 false, 616 true, 617 ReadPixelsTest::TestSpec::FRAMEBUFFERTYPE_NATIVE, 618 GL_NONE 619 } 620 }; 621 622 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(nativeFramebufferTests); testNdx++) 623 { 624 nativeFramebufferGroup->addChild(new ReadPixelsTest(m_context, nativeFramebufferTests[testNdx])); 625 } 626 627 addChild(nativeFramebufferGroup); 628 629 TestCaseGroup* renderbufferGroup = new TestCaseGroup(m_context, "renderbuffer", "Tests with reading from renderbuffer"); 630 631 GLenum renderbufferFormats[] = { 632 GL_RGBA8, 633 GL_RGBA8I, 634 GL_RGBA8UI, 635 GL_RGBA16F, 636 GL_RGBA16I, 637 GL_RGBA16UI, 638 GL_RGBA32F, 639 GL_RGBA32I, 640 GL_RGBA32UI, 641 642 GL_SRGB8_ALPHA8, 643 GL_RGB10_A2, 644 GL_RGB10_A2UI, 645 GL_RGBA4, 646 GL_RGB5_A1, 647 648 GL_RGB8, 649 GL_RGB565, 650 651 GL_R11F_G11F_B10F, 652 653 GL_RG8, 654 GL_RG8I, 655 GL_RG8UI, 656 GL_RG16F, 657 GL_RG16I, 658 GL_RG16UI, 659 GL_RG32F, 660 GL_RG32I, 661 GL_RG32UI 662 }; 663 664 const char* renderbufferFormatsStr[] = { 665 "rgba8", 666 "rgba8i", 667 "rgba8ui", 668 "rgba16f", 669 "rgba16i", 670 "rgba16ui", 671 "rgba32f", 672 "rgba32i", 673 "rgba32ui", 674 675 "srgb8_alpha8", 676 "rgb10_a2", 677 "rgb10_a2ui", 678 "rgba4", 679 "rgb5_a1", 680 681 "rgb8", 682 "rgb565", 683 684 "r11f_g11f_b10f", 685 686 "rg8", 687 "rg8i", 688 "rg8ui", 689 "rg16f", 690 "rg16i", 691 "rg16ui", 692 "rg32f", 693 "rg32i", 694 "rg32ui" 695 }; 696 697 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(renderbufferFormatsStr) == DE_LENGTH_OF_ARRAY(renderbufferFormats)); 698 699 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(renderbufferFormats); formatNdx++) 700 { 701 for (int trianglesClears = 0; trianglesClears < 2; trianglesClears++) 702 { 703 ReadPixelsTest::TestSpec testSpec; 704 705 testSpec.name = string(renderbufferFormatsStr [formatNdx]) + "_" + (trianglesClears == 0 ? "triangles" : "clears"), 706 testSpec.description = testSpec.name; 707 testSpec.useColorClear = trianglesClears == 1, 708 testSpec.renderTriangles = trianglesClears == 0, 709 testSpec.framebufferType = ReadPixelsTest::TestSpec::FRAMEBUFFERTYPE_RENDERBUFFER, 710 testSpec.renderbufferFormat = renderbufferFormats[formatNdx]; 711 712 renderbufferGroup->addChild(new ReadPixelsTest(m_context, testSpec)); 713 } 714 } 715 716 addChild(renderbufferGroup); 717 } 718 719 } // Functional 720 } // gles3 721 } // deqp 722
