1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2017 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 EXT Shader Framebuffer Fetch Tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fShaderFramebufferFetchTests.hpp" 25 #include "es31fFboTestUtil.hpp" 26 27 #include "tcuTestLog.hpp" 28 #include "tcuSurface.hpp" 29 #include "tcuTextureUtil.hpp" 30 #include "tcuImageCompare.hpp" 31 #include "tcuVectorUtil.hpp" 32 33 #include "gluShaderProgram.hpp" 34 #include "gluPixelTransfer.hpp" 35 #include "gluTextureUtil.hpp" 36 #include "gluContextInfo.hpp" 37 #include "gluObjectWrapper.hpp" 38 39 #include "glwFunctions.hpp" 40 #include "glwEnums.hpp" 41 42 #include "deStringUtil.hpp" 43 44 #include <vector> 45 46 namespace deqp 47 { 48 namespace gles31 49 { 50 namespace Functional 51 { 52 namespace 53 { 54 55 using std::vector; 56 using std::string; 57 using tcu::TestLog; 58 59 using namespace glw; 60 using namespace FboTestUtil; 61 62 static void checkExtensionSupport (Context& context, const char* extName) 63 { 64 if (!context.getContextInfo().isExtensionSupported(extName)) 65 throw tcu::NotSupportedError(string(extName) + " not supported"); 66 } 67 68 static void checkFramebufferFetchSupport (Context& context) 69 { 70 checkExtensionSupport(context, "GL_EXT_shader_framebuffer_fetch"); 71 } 72 73 static bool isRequiredFormat (deUint32 format, glu::RenderContext& renderContext) 74 { 75 const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)); 76 switch (format) 77 { 78 // Color-renderable formats 79 case GL_RGBA32I: 80 case GL_RGBA32UI: 81 case GL_RGBA16I: 82 case GL_RGBA16UI: 83 case GL_RGBA8: 84 case GL_RGBA8I: 85 case GL_RGBA8UI: 86 case GL_SRGB8_ALPHA8: 87 case GL_RGB10_A2: 88 case GL_RGB10_A2UI: 89 case GL_RGBA4: 90 case GL_RGB5_A1: 91 case GL_RGB8: 92 case GL_RGB565: 93 case GL_RG32I: 94 case GL_RG32UI: 95 case GL_RG16I: 96 case GL_RG16UI: 97 case GL_RG8: 98 case GL_RG8I: 99 case GL_RG8UI: 100 case GL_R32I: 101 case GL_R32UI: 102 case GL_R16I: 103 case GL_R16UI: 104 case GL_R8: 105 case GL_R8I: 106 case GL_R8UI: 107 return true; 108 109 // Float format 110 case GL_RGBA32F: 111 case GL_RGB32F: 112 case GL_R11F_G11F_B10F: 113 case GL_RG32F: 114 case GL_R32F: 115 return isES32; 116 117 default: 118 return false; 119 } 120 } 121 122 tcu::TextureFormat getReadPixelFormat (const tcu::TextureFormat& format) 123 { 124 switch (tcu::getTextureChannelClass(format.type)) 125 { 126 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 127 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32); 128 129 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 130 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32); 131 132 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 133 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 134 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8); 135 136 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 137 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT); 138 139 default: 140 DE_ASSERT(false); 141 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8); 142 } 143 } 144 145 tcu::Vec4 getFixedPointFormatThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat) 146 { 147 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT); 148 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT); 149 150 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER); 151 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER); 152 153 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 154 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 155 156 const tcu::IVec4 srcBits = tcu::getTextureFormatBitDepth(sourceFormat); 157 const tcu::IVec4 readBits = tcu::getTextureFormatBitDepth(readPixelsFormat); 158 159 return tcu::Vec4(3.0f) / ((tcu::Vector<deUint64, 4>(1) << (tcu::min(srcBits, readBits).cast<deUint64>())) - tcu::Vector<deUint64, 4>(1)).cast<float>(); 160 } 161 162 tcu::UVec4 getFloatULPThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat) 163 { 164 const tcu::IVec4 srcMantissaBits = tcu::getTextureFormatMantissaBitDepth(sourceFormat); 165 const tcu::IVec4 readMantissaBits = tcu::getTextureFormatMantissaBitDepth(readPixelsFormat); 166 tcu::IVec4 ULPDiff(0); 167 168 for (int i = 0; i < 4; i++) 169 if (readMantissaBits[i] >= srcMantissaBits[i]) 170 ULPDiff[i] = readMantissaBits[i] - srcMantissaBits[i]; 171 172 return tcu::UVec4(4) * (tcu::UVec4(1) << (ULPDiff.cast<deUint32>())); 173 } 174 175 static bool isAnyExtensionSupported (Context& context, const std::vector<std::string>& requiredExts) 176 { 177 for (std::vector<std::string>::const_iterator iter = requiredExts.begin(); iter != requiredExts.end(); iter++) 178 { 179 const std::string& extension = *iter; 180 181 if (context.getContextInfo().isExtensionSupported(extension.c_str())) 182 return true; 183 } 184 185 return false; 186 } 187 188 static std::string getColorOutputType(tcu::TextureFormat format) 189 { 190 switch (tcu::getTextureChannelClass(format.type)) 191 { 192 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: return "uvec4"; 193 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: return "ivec4"; 194 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 195 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 196 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: return "vec4"; 197 default: 198 DE_FATAL("Unsupported TEXTURECHANNELCLASS"); 199 return ""; 200 } 201 } 202 203 static std::vector<std::string> getEnablingExtensions (deUint32 format, glu::RenderContext& renderContext) 204 { 205 const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)); 206 std::vector<std::string> out; 207 208 DE_ASSERT(!isRequiredFormat(format, renderContext)); 209 210 switch (format) 211 { 212 case GL_RGB16F: 213 out.push_back("GL_EXT_color_buffer_half_float"); 214 break; 215 216 case GL_RGBA16F: 217 case GL_RG16F: 218 case GL_R16F: 219 out.push_back("GL_EXT_color_buffer_half_float"); 220 221 case GL_RGBA32F: 222 case GL_RGB32F: 223 case GL_R11F_G11F_B10F: 224 case GL_RG32F: 225 case GL_R32F: 226 if (!isES32) 227 out.push_back("GL_EXT_color_buffer_float"); 228 break; 229 230 default: 231 break; 232 } 233 234 return out; 235 } 236 237 void checkFormatSupport (Context& context, deUint32 sizedFormat) 238 { 239 const bool isCoreFormat = isRequiredFormat(sizedFormat, context.getRenderContext()); 240 const std::vector<std::string> requiredExts = (!isCoreFormat) ? getEnablingExtensions(sizedFormat, context.getRenderContext()) : std::vector<std::string>(); 241 242 // Check that we don't try to use invalid formats. 243 DE_ASSERT(isCoreFormat || !requiredExts.empty()); 244 245 if (!requiredExts.empty() && !isAnyExtensionSupported(context, requiredExts)) 246 throw tcu::NotSupportedError("Format not supported"); 247 } 248 249 tcu::Vec4 scaleColorValue (tcu::TextureFormat format, const tcu::Vec4& color) 250 { 251 const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(format); 252 const tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 253 const tcu::Vec4 cBias = fmtInfo.valueMin; 254 255 return tcu::RGBA(color).toVec() * cScale + cBias; 256 } 257 258 // Base class for framebuffer fetch test cases 259 260 class FramebufferFetchTestCase : public TestCase 261 { 262 public: 263 FramebufferFetchTestCase (Context& context, const char* name, const char* desc, deUint32 format); 264 ~FramebufferFetchTestCase (void); 265 266 void init (void); 267 void deinit (void); 268 269 protected: 270 string genPassThroughVertSource (void); 271 virtual glu::ProgramSources genShaderSources (void); 272 273 void genFramebufferWithTexture (const tcu::Vec4& color); 274 void genAttachementTexture (const tcu::Vec4& color); 275 void genUniformColor (const tcu::Vec4& color); 276 277 void render (void); 278 void verifyRenderbuffer (TestLog& log, const tcu::TextureFormat& format, const tcu::TextureLevel& reference, const tcu::TextureLevel& result); 279 280 const glw::Functions& m_gl; 281 const deUint32 m_format; 282 283 glu::ShaderProgram* m_program; 284 GLuint m_framebuffer; 285 GLuint m_texColorBuffer; 286 287 tcu::TextureFormat m_texFmt; 288 glu::TransferFormat m_transferFmt; 289 bool m_isFilterable; 290 291 enum 292 { 293 VIEWPORT_WIDTH = 64, 294 VIEWPORT_HEIGHT = 64, 295 }; 296 }; 297 298 FramebufferFetchTestCase::FramebufferFetchTestCase (Context& context, const char* name, const char* desc, deUint32 format) 299 : TestCase (context, name, desc) 300 , m_gl (m_context.getRenderContext().getFunctions()) 301 , m_format (format) 302 , m_program (DE_NULL) 303 , m_framebuffer (0) 304 , m_texColorBuffer (0) 305 , m_texFmt (glu::mapGLInternalFormat(m_format)) 306 , m_transferFmt (glu::getTransferFormat(m_texFmt)) 307 , m_isFilterable (glu::isGLInternalColorFormatFilterable(m_format)) 308 { 309 } 310 311 FramebufferFetchTestCase::~FramebufferFetchTestCase (void) 312 { 313 FramebufferFetchTestCase::deinit(); 314 } 315 316 void FramebufferFetchTestCase::init (void) 317 { 318 checkFramebufferFetchSupport (m_context); 319 checkFormatSupport(m_context, m_format); 320 321 DE_ASSERT(!m_program); 322 m_program = new glu::ShaderProgram(m_context.getRenderContext(), genShaderSources()); 323 324 m_testCtx.getLog() << *m_program; 325 326 if (!m_program->isOk()) 327 { 328 delete m_program; 329 m_program = DE_NULL; 330 TCU_FAIL("Failed to compile shader program"); 331 } 332 333 m_gl.useProgram(m_program->getProgram()); 334 } 335 336 void FramebufferFetchTestCase::deinit (void) 337 { 338 delete m_program; 339 m_program = DE_NULL; 340 341 if (m_framebuffer) 342 { 343 m_gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 344 m_gl.deleteFramebuffers(1, &m_framebuffer); 345 m_framebuffer = 0; 346 } 347 348 if (m_texColorBuffer) 349 { 350 m_gl.deleteTextures(1, &m_texColorBuffer); 351 m_texColorBuffer = 0; 352 } 353 } 354 355 string FramebufferFetchTestCase::genPassThroughVertSource (void) 356 { 357 std::ostringstream vertShaderSource; 358 359 vertShaderSource << "#version 310 es\n" 360 << "in highp vec4 a_position;\n" 361 << "\n" 362 << "void main (void)\n" 363 << "{\n" 364 << " gl_Position = a_position;\n" 365 << "}\n"; 366 367 return vertShaderSource.str(); 368 } 369 370 glu::ProgramSources FramebufferFetchTestCase::genShaderSources (void) 371 { 372 const string vecType = getColorOutputType(m_texFmt); 373 std::ostringstream fragShaderSource; 374 375 fragShaderSource << "#version 310 es\n" 376 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 377 << "layout(location = 0) inout highp " << vecType << " o_color;\n" 378 << "uniform highp " << vecType << " u_color;\n" 379 << "\n" 380 << "void main (void)\n" 381 << "{\n" 382 << " o_color += u_color;\n" 383 << "}\n"; 384 385 return glu::makeVtxFragSources(genPassThroughVertSource(), fragShaderSource.str()); 386 } 387 388 void FramebufferFetchTestCase::genFramebufferWithTexture (const tcu::Vec4& color) 389 { 390 m_gl.genFramebuffers(1, &m_framebuffer); 391 m_gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 392 393 genAttachementTexture(color); 394 GLU_EXPECT_NO_ERROR(m_gl.getError(), "genAttachementTexture()"); 395 396 m_gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texColorBuffer, 0); 397 TCU_CHECK(m_gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); 398 } 399 400 void FramebufferFetchTestCase::genAttachementTexture (const tcu::Vec4& color) 401 { 402 tcu::TextureLevel data (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 403 tcu::TextureChannelClass textureChannelClass = tcu::getTextureChannelClass(m_texFmt.type); 404 405 m_gl.genTextures(1, &m_texColorBuffer); 406 m_gl.bindTexture(GL_TEXTURE_2D, m_texColorBuffer); 407 408 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 409 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 410 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 411 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isFilterable ? GL_LINEAR : GL_NEAREST); 412 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_isFilterable ? GL_LINEAR : GL_NEAREST); 413 414 if (textureChannelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 415 tcu::clear(data.getAccess(), color.asUint()); 416 else if (textureChannelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 417 tcu::clear(data.getAccess(), color.asInt()); 418 else 419 tcu::clear(data.getAccess(), color); 420 421 m_gl.texImage2D(GL_TEXTURE_2D, 0, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 0, m_transferFmt.format, m_transferFmt.dataType, data.getAccess().getDataPtr()); 422 m_gl.bindTexture(GL_TEXTURE_2D, 0); 423 } 424 425 void FramebufferFetchTestCase::verifyRenderbuffer (TestLog& log, const tcu::TextureFormat& format, const tcu::TextureLevel& reference, const tcu::TextureLevel& result) 426 { 427 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 428 429 switch (tcu::getTextureChannelClass(format.type)) 430 { 431 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 432 { 433 const string name = "Renderbuffer"; 434 const string desc = "Compare renderbuffer (floating_point)"; 435 const tcu::UVec4 threshold = getFloatULPThreshold(format, result.getFormat()); 436 437 if (!tcu::floatUlpThresholdCompare(log, name.c_str(), desc.c_str(), reference, result, threshold, tcu::COMPARE_LOG_RESULT)) 438 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 439 440 break; 441 } 442 443 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 444 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 445 { 446 const string name = "Renderbuffer"; 447 const string desc = "Compare renderbuffer (integer)"; 448 const tcu::UVec4 threshold (1, 1, 1, 1); 449 450 if (!tcu::intThresholdCompare(log, name.c_str(), desc.c_str(), reference, result, threshold, tcu::COMPARE_LOG_RESULT)) 451 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 452 453 break; 454 } 455 456 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 457 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 458 { 459 const string name = "Renderbuffer"; 460 const string desc = "Compare renderbuffer (fixed point)"; 461 const tcu::Vec4 threshold = getFixedPointFormatThreshold(format, result.getFormat()); 462 463 if (!tcu::floatThresholdCompare(log, name.c_str(), desc.c_str(), reference, result, threshold, tcu::COMPARE_LOG_RESULT)) 464 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 465 466 break; 467 } 468 469 default: 470 { 471 DE_ASSERT(DE_FALSE); 472 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 473 } 474 } 475 } 476 477 void FramebufferFetchTestCase::genUniformColor (const tcu::Vec4& color) 478 { 479 const GLuint colorLocation = m_gl.getUniformLocation(m_program->getProgram(), "u_color"); 480 481 switch (tcu::getTextureChannelClass(m_texFmt.type)) 482 { 483 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 484 { 485 m_gl.uniform4uiv(colorLocation, 1, color.asUint().getPtr()); 486 break; 487 } 488 489 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 490 { 491 m_gl.uniform4iv(colorLocation, 1, color.asInt().getPtr()); 492 break; 493 } 494 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 495 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 496 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 497 { 498 m_gl.uniform4fv(colorLocation, 1, color.asFloat().getPtr()); 499 break; 500 } 501 default: 502 DE_ASSERT(DE_FALSE); 503 } 504 505 GLU_EXPECT_NO_ERROR(m_gl.getError(), "genUniformColor()"); 506 } 507 508 void FramebufferFetchTestCase::render (void) 509 { 510 const GLfloat coords[] = 511 { 512 -1.0f, -1.0f, 513 +1.0f, -1.0f, 514 +1.0f, +1.0f, 515 -1.0f, +1.0f, 516 }; 517 518 const GLushort indices[] = 519 { 520 0, 1, 2, 2, 3, 0, 521 }; 522 523 const GLuint coordLocation = m_gl.getAttribLocation(m_program->getProgram(), "a_position"); 524 525 m_gl.viewport(0, 0, VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 526 527 glu::Buffer coordinatesBuffer(m_context.getRenderContext()); 528 glu::Buffer elementsBuffer(m_context.getRenderContext()); 529 530 m_gl.bindBuffer(GL_ARRAY_BUFFER, *coordinatesBuffer); 531 m_gl.bufferData(GL_ARRAY_BUFFER, (GLsizeiptr)sizeof(coords), coords, GL_STATIC_DRAW); 532 m_gl.enableVertexAttribArray(coordLocation); 533 m_gl.vertexAttribPointer(coordLocation, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL); 534 535 m_gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, *elementsBuffer); 536 m_gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)sizeof(indices), &indices[0], GL_STATIC_DRAW); 537 538 m_gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, DE_NULL); 539 GLU_EXPECT_NO_ERROR(m_gl.getError(), "render()"); 540 } 541 542 // Test description: 543 // - Attach texture containing solid color to framebuffer. 544 // - Draw full quad covering the entire viewport. 545 // - Sum framebuffer read color with passed in uniform color. 546 // - Compare resulting surface with reference. 547 548 class TextureFormatTestCase : public FramebufferFetchTestCase 549 { 550 public: 551 TextureFormatTestCase (Context& context, const char* name, const char* desc, deUint32 format); 552 ~TextureFormatTestCase (void) {}; 553 554 IterateResult iterate (void); 555 556 private: 557 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor); 558 }; 559 560 TextureFormatTestCase::TextureFormatTestCase (Context& context, const char* name, const char* desc, deUint32 format) 561 : FramebufferFetchTestCase(context, name, desc, format) 562 { 563 } 564 565 tcu::TextureLevel TextureFormatTestCase::genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor) 566 { 567 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 568 tcu::TextureChannelClass textureChannelClass = tcu::getTextureChannelClass(m_texFmt.type); 569 570 if (textureChannelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 571 { 572 tcu::clear(reference.getAccess(), fbColor.asUint() + uniformColor.asUint()); 573 } 574 else if (textureChannelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 575 { 576 tcu::clear(reference.getAccess(), fbColor.asInt() + uniformColor.asInt()); 577 } 578 else 579 { 580 if (tcu::isSRGB(m_texFmt)) 581 { 582 const tcu::Vec4 fragmentColor = tcu::sRGBToLinear(fbColor) + uniformColor; 583 tcu::clear(reference.getAccess(), tcu::linearToSRGB(fragmentColor)); 584 } 585 else 586 { 587 tcu::clear(reference.getAccess(), fbColor + uniformColor); 588 } 589 } 590 591 return reference; 592 } 593 594 TextureFormatTestCase::IterateResult TextureFormatTestCase::iterate (void) 595 { 596 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.1f, 0.1f, 0.1f, 1.0f)); 597 const tcu::Vec4 fbColor = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f)); 598 599 tcu::TextureLevel reference = genReferenceTexture(fbColor, uniformColor); 600 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 601 602 genFramebufferWithTexture(fbColor); 603 genUniformColor(uniformColor); 604 render(); 605 606 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 607 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 608 609 return STOP; 610 } 611 612 // Test description: 613 // - Attach multiple textures containing solid colors to framebuffer. 614 // - Draw full quad covering the entire viewport. 615 // - For each render target sum framebuffer read color with passed in uniform color. 616 // - Compare resulting surfaces with references. 617 618 class MultipleRenderTargetsTestCase : public FramebufferFetchTestCase 619 { 620 public: 621 MultipleRenderTargetsTestCase (Context& context, const char* name, const char* desc, deUint32 format); 622 ~MultipleRenderTargetsTestCase (void); 623 624 IterateResult iterate (void); 625 void deinit (void); 626 627 private: 628 void genFramebufferWithTextures (const vector<tcu::Vec4>& colors); 629 void genAttachmentTextures (const vector<tcu::Vec4>& colors); 630 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor); 631 glu::ProgramSources genShaderSources (void); 632 633 enum 634 { 635 MAX_COLOR_BUFFERS = 4 636 }; 637 638 GLuint m_texColorBuffers [MAX_COLOR_BUFFERS]; 639 GLenum m_colorBuffers [MAX_COLOR_BUFFERS]; 640 }; 641 642 MultipleRenderTargetsTestCase::MultipleRenderTargetsTestCase (Context& context, const char* name, const char* desc, deUint32 format) 643 : FramebufferFetchTestCase(context, name, desc, format) 644 , m_texColorBuffers () 645 { 646 m_colorBuffers[0] = GL_COLOR_ATTACHMENT0; 647 m_colorBuffers[1] = GL_COLOR_ATTACHMENT1; 648 m_colorBuffers[2] = GL_COLOR_ATTACHMENT2; 649 m_colorBuffers[3] = GL_COLOR_ATTACHMENT3; 650 } 651 652 MultipleRenderTargetsTestCase::~MultipleRenderTargetsTestCase (void) 653 { 654 MultipleRenderTargetsTestCase::deinit(); 655 } 656 657 void MultipleRenderTargetsTestCase::deinit (void) 658 { 659 // Clean up texture data 660 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_texColorBuffers); ++i) 661 { 662 if (m_texColorBuffers[i]) 663 m_context.getRenderContext().getFunctions().deleteTextures(1, &m_texColorBuffers[i]); 664 } 665 666 FramebufferFetchTestCase::deinit(); 667 } 668 669 void MultipleRenderTargetsTestCase::genFramebufferWithTextures (const vector<tcu::Vec4>& colors) 670 { 671 m_gl.genFramebuffers(1, &m_framebuffer); 672 m_gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 673 674 genAttachmentTextures(colors); 675 676 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_texColorBuffers); ++i) 677 m_gl.framebufferTexture2D(GL_FRAMEBUFFER, m_colorBuffers[i], GL_TEXTURE_2D, m_texColorBuffers[i], 0); 678 679 TCU_CHECK(m_gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); 680 681 m_gl.drawBuffers((glw::GLsizei)MAX_COLOR_BUFFERS, &m_colorBuffers[0]); 682 GLU_EXPECT_NO_ERROR(m_gl.getError(), "genFramebufferWithTextures()"); 683 } 684 685 void MultipleRenderTargetsTestCase::genAttachmentTextures (const vector<tcu::Vec4>& colors) 686 { 687 tcu::TextureLevel data (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 688 689 m_gl.genTextures(MAX_COLOR_BUFFERS, m_texColorBuffers); 690 691 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_texColorBuffers); ++i) 692 { 693 m_gl.bindTexture(GL_TEXTURE_2D, m_texColorBuffers[i]); 694 695 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 696 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 697 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 698 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isFilterable ? GL_LINEAR : GL_NEAREST); 699 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_isFilterable ? GL_LINEAR : GL_NEAREST); 700 701 clear(data.getAccess(), colors[i]); 702 m_gl.texImage2D(GL_TEXTURE_2D, 0, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 0, m_transferFmt.format, m_transferFmt.dataType, data.getAccess().getDataPtr()); 703 } 704 705 m_gl.bindTexture(GL_TEXTURE_2D, 0); 706 GLU_EXPECT_NO_ERROR(m_gl.getError(), "genAttachmentTextures()"); 707 } 708 709 tcu::TextureLevel MultipleRenderTargetsTestCase::genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor) 710 { 711 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 712 tcu::clear(reference.getAccess(), fbColor + uniformColor); 713 714 return reference; 715 } 716 717 glu::ProgramSources MultipleRenderTargetsTestCase::genShaderSources (void) 718 { 719 const string vecType = getColorOutputType(m_texFmt); 720 std::ostringstream fragShaderSource; 721 722 fragShaderSource << "#version 310 es\n" 723 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 724 << "layout(location = 0) inout highp " << vecType << " o_color0;\n" 725 << "layout(location = 1) inout highp " << vecType << " o_color1;\n" 726 << "layout(location = 2) inout highp " << vecType << " o_color2;\n" 727 << "layout(location = 3) inout highp " << vecType << " o_color3;\n" 728 << "uniform highp " << vecType << " u_color;\n" 729 << "\n" 730 << "void main (void)\n" 731 << "{\n" 732 << " o_color0 += u_color;\n" 733 << " o_color1 += u_color;\n" 734 << " o_color2 += u_color;\n" 735 << " o_color3 += u_color;\n" 736 << "}\n"; 737 738 return glu::makeVtxFragSources(genPassThroughVertSource(), fragShaderSource.str()); 739 } 740 741 MultipleRenderTargetsTestCase::IterateResult MultipleRenderTargetsTestCase::iterate (void) 742 { 743 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.1f, 0.1f, 0.1f, 1.0f)); 744 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 745 746 vector<tcu::Vec4> colors; 747 colors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.9f, 0.0f, 0.0f, 1.0f))); 748 colors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 0.9f, 0.0f, 1.0f))); 749 colors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 0.0f, 0.9f, 1.0f))); 750 colors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 0.9f, 0.9f, 1.0f))); 751 752 genFramebufferWithTextures(colors); 753 genUniformColor(uniformColor); 754 render(); 755 756 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_colorBuffers); ++i) 757 { 758 tcu::TextureLevel reference = genReferenceTexture(colors[i], uniformColor); 759 760 m_gl.readBuffer(m_colorBuffers[i]); 761 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 762 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 763 } 764 765 return STOP; 766 } 767 768 // Test description: 769 // - Same as TextureFormatTestCase except uses built-in fragment output of ES 2.0 770 771 class LastFragDataTestCase : public FramebufferFetchTestCase 772 { 773 public: 774 LastFragDataTestCase (Context& context, const char* name, const char* desc, deUint32 format); 775 ~LastFragDataTestCase (void) {}; 776 777 IterateResult iterate (void); 778 779 private: 780 glu::ProgramSources genShaderSources (void); 781 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor); 782 }; 783 784 LastFragDataTestCase::LastFragDataTestCase (Context& context, const char* name, const char* desc, deUint32 format) 785 : FramebufferFetchTestCase(context, name, desc, format) 786 { 787 } 788 789 glu::ProgramSources LastFragDataTestCase::genShaderSources (void) 790 { 791 const string vecType = getColorOutputType(m_texFmt); 792 std::ostringstream vertShaderSource; 793 std::ostringstream fragShaderSource; 794 795 vertShaderSource << "#version 100\n" 796 << "attribute vec4 a_position;\n" 797 << "\n" 798 << "void main (void)\n" 799 << "{\n" 800 << " gl_Position = a_position;\n" 801 << "}\n"; 802 803 fragShaderSource << "#version 100\n" 804 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 805 << "uniform highp " << vecType << " u_color;\n" 806 << "\n" 807 << "void main (void)\n" 808 << "{\n" 809 << " gl_FragColor = u_color + gl_LastFragData[0];\n" 810 << "}\n"; 811 812 return glu::makeVtxFragSources(vertShaderSource.str(), fragShaderSource.str()); 813 } 814 815 tcu::TextureLevel LastFragDataTestCase::genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor) 816 { 817 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 818 tcu::clear(reference.getAccess(), fbColor + uniformColor); 819 820 return reference; 821 } 822 823 LastFragDataTestCase::IterateResult LastFragDataTestCase::iterate (void) 824 { 825 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.1f, 0.1f, 0.1f, 1.0f)); 826 const tcu::Vec4 fbColor = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f)); 827 828 tcu::TextureLevel reference = genReferenceTexture(fbColor, uniformColor); 829 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 830 831 genFramebufferWithTexture(fbColor); 832 genUniformColor(uniformColor); 833 render(); 834 835 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 836 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 837 838 return STOP; 839 } 840 841 // Test description: 842 // - Attach texture containing solid color to framebuffer. 843 // - Create one 2D texture for sampler with a grid pattern 844 // - Draw full screen quad covering the entire viewport. 845 // - Sum color values taken from framebuffer texture and sampled texture 846 // - Compare resulting surface with reference. 847 848 class TexelFetchTestCase : public FramebufferFetchTestCase 849 { 850 public: 851 TexelFetchTestCase (Context& context, const char* name, const char* desc, deUint32 format); 852 ~TexelFetchTestCase (void) {} 853 854 IterateResult iterate (void); 855 856 private: 857 glu::ProgramSources genShaderSources (void); 858 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& colorEven, const tcu::Vec4& colorOdd, const tcu::Vec4& fbColor); 859 void genSamplerTexture (const tcu::Vec4& colorEven, const tcu::Vec4& colorOdd); 860 861 GLuint m_samplerTexture; 862 }; 863 864 TexelFetchTestCase::TexelFetchTestCase (Context& context, const char* name, const char* desc, deUint32 format) 865 : FramebufferFetchTestCase(context, name, desc, format) 866 , m_samplerTexture(0) 867 { 868 } 869 870 void TexelFetchTestCase::genSamplerTexture (const tcu::Vec4& colorEven, const tcu::Vec4& colorOdd) 871 { 872 tcu::TextureLevel data (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 873 874 m_gl.activeTexture(GL_TEXTURE1); 875 876 m_gl.genTextures(1, &m_samplerTexture); 877 m_gl.bindTexture(GL_TEXTURE_2D, m_texColorBuffer); 878 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 879 m_gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 880 881 tcu::fillWithGrid(data.getAccess(), 8, colorEven, colorOdd); 882 883 m_gl.texImage2D(GL_TEXTURE_2D, 0, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 0, m_transferFmt.format, m_transferFmt.dataType, data.getAccess().getDataPtr()); 884 m_gl.bindTexture(GL_TEXTURE_2D, 0); 885 886 const GLuint samplerLocation = m_gl.getUniformLocation(m_program->getProgram(), "u_sampler"); 887 m_gl.uniform1i(samplerLocation, 1); 888 889 GLU_EXPECT_NO_ERROR(m_gl.getError(), "genSamplerTexture()"); 890 } 891 892 glu::ProgramSources TexelFetchTestCase::genShaderSources (void) 893 { 894 const string vecType = getColorOutputType(m_texFmt); 895 std::ostringstream fragShaderSource; 896 897 fragShaderSource << "#version 310 es\n" 898 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 899 << "layout(location = 0) inout highp " << vecType << " o_color;\n" 900 << "\n" 901 << "uniform sampler2D u_sampler;\n" 902 << "void main (void)\n" 903 << "{\n" 904 << " o_color += texelFetch(u_sampler, ivec2(gl_FragCoord), 0);\n" 905 << "}\n"; 906 907 return glu::makeVtxFragSources(genPassThroughVertSource(), fragShaderSource.str()); 908 } 909 910 tcu::TextureLevel TexelFetchTestCase::genReferenceTexture (const tcu::Vec4& colorEven, const tcu::Vec4& colorOdd, const tcu::Vec4& fbColor) 911 { 912 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 913 tcu::fillWithGrid(reference.getAccess(), 8, colorEven + fbColor, colorOdd + fbColor); 914 915 return reference; 916 } 917 918 TexelFetchTestCase::IterateResult TexelFetchTestCase::iterate (void) 919 { 920 const tcu::Vec4 fbColor = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 0.5f, 1.0f)); 921 const tcu::Vec4 colorEven = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.5f, 0.0f, 1.0f)); 922 const tcu::Vec4 colorOdd = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 0.5f, 1.0f)); 923 924 genSamplerTexture(colorEven, colorOdd); 925 tcu::TextureLevel reference = genReferenceTexture(colorEven, colorOdd, fbColor); 926 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 927 928 genFramebufferWithTexture(fbColor); 929 render(); 930 931 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 932 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 933 934 // cleanup 935 m_gl.deleteTextures(1, &m_samplerTexture); 936 937 return STOP; 938 } 939 940 // Test description: 941 // - Attach texture containing solid color to framebuffer. 942 // - Draw full screen quad covering the entire viewport. 943 // - Multiple assignments are made to the output color for fragments on the right vertical half of the screen. 944 // - A single assignment is made to the output color for fragments on the left vertical centre of the screen. 945 // - Values are calculated using the sum of the passed in uniform color and the previous framebuffer color. 946 // - Compare resulting surface with reference. 947 948 class MultipleAssignmentTestCase : public FramebufferFetchTestCase 949 { 950 public: 951 MultipleAssignmentTestCase (Context& context, const char* name, const char* desc, deUint32 format); 952 ~MultipleAssignmentTestCase (void) {} 953 954 IterateResult iterate (void); 955 956 private: 957 glu::ProgramSources genShaderSources (void); 958 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor); 959 }; 960 961 MultipleAssignmentTestCase::MultipleAssignmentTestCase (Context& context, const char* name, const char* desc, deUint32 format) 962 : FramebufferFetchTestCase(context, name, desc, format) 963 { 964 } 965 966 glu::ProgramSources MultipleAssignmentTestCase::genShaderSources (void) 967 { 968 const string vecType = getColorOutputType(m_texFmt); 969 std::ostringstream vertShaderSource; 970 std::ostringstream fragShaderSource; 971 972 vertShaderSource << "#version 310 es\n" 973 << "in highp vec4 a_position;\n" 974 << "out highp vec4 v_position;\n" 975 << "\n" 976 << "void main (void)\n" 977 << "{\n" 978 << " gl_Position = a_position;\n" 979 << " v_position = gl_Position;\n" 980 << "}\n"; 981 982 fragShaderSource << "#version 310 es\n" 983 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 984 << "in highp vec4 v_position;\n" 985 << "layout(location = 0) inout highp " << vecType << " o_color;\n" 986 << "uniform highp " << vecType << " u_color;\n" 987 << "\n" 988 << "void main (void)\n" 989 << "{\n" 990 << " if (v_position.x > 0.0f)\n" 991 << " o_color += u_color;\n" 992 << "\n" 993 << " o_color += u_color;\n" 994 << "}\n"; 995 996 return glu::makeVtxFragSources(vertShaderSource.str(), fragShaderSource.str()); 997 } 998 999 tcu::TextureLevel MultipleAssignmentTestCase::genReferenceTexture (const tcu::Vec4& fbColor, const tcu::Vec4& uniformColor) 1000 { 1001 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 1002 1003 int width = reference.getAccess().getWidth(); 1004 int height = reference.getAccess().getHeight(); 1005 int left = width /2; 1006 int top = height/2; 1007 1008 tcu::Vec4 compositeColor(uniformColor * 2.0f); 1009 1010 tcu::clear(getSubregion(reference.getAccess(), left, 0, 0, width-left, top, 1), fbColor + compositeColor); 1011 tcu::clear(getSubregion(reference.getAccess(), 0, top, 0, left, height-top, 1), fbColor + uniformColor); 1012 tcu::clear(getSubregion(reference.getAccess(), left, top, 0, width-left, height-top, 1), fbColor + compositeColor); 1013 tcu::clear(getSubregion(reference.getAccess(), 0, 0, 0, left, top, 1), fbColor + uniformColor); 1014 1015 return reference; 1016 } 1017 1018 MultipleAssignmentTestCase::IterateResult MultipleAssignmentTestCase::iterate (void) 1019 { 1020 const tcu::Vec4 fbColor = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f)); 1021 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.25f, 0.0f, 0.0f, 1.0f)); 1022 1023 tcu::TextureLevel reference = genReferenceTexture(fbColor, uniformColor); 1024 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 1025 1026 genFramebufferWithTexture(fbColor); 1027 genUniformColor(uniformColor); 1028 render(); 1029 1030 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 1031 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 1032 1033 return STOP; 1034 } 1035 1036 // Test description: 1037 // - Attach texture containing grid pattern to framebuffer. 1038 // - Using framebuffer reads discard odd squares in the grid. 1039 // - The even squares framebuffer color is added to the passed in uniform color. 1040 1041 class FragmentDiscardTestCase : public FramebufferFetchTestCase 1042 { 1043 public: 1044 FragmentDiscardTestCase (Context& context, const char* name, const char* desc, deUint32 format); 1045 ~FragmentDiscardTestCase (void) {} 1046 1047 IterateResult iterate (void); 1048 1049 private: 1050 glu::ProgramSources genShaderSources (void); 1051 void genFramebufferWithGrid (const tcu::Vec4& fbColorEven, const tcu::Vec4& fbColorOdd); 1052 tcu::TextureLevel genReferenceTexture (const tcu::Vec4& fbColorEven, const tcu::Vec4& fbColorOdd); 1053 }; 1054 1055 FragmentDiscardTestCase::FragmentDiscardTestCase (Context& context, const char* name, const char* desc, deUint32 format) 1056 : FramebufferFetchTestCase(context, name, desc, format) 1057 { 1058 } 1059 1060 glu::ProgramSources FragmentDiscardTestCase::genShaderSources (void) 1061 { 1062 const string vecType = getColorOutputType(m_texFmt); 1063 std::ostringstream fragShaderSource; 1064 1065 fragShaderSource << "#version 310 es\n" 1066 << "#extension GL_EXT_shader_framebuffer_fetch : require\n" 1067 << "layout(location = 0) inout highp " << vecType << " o_color;\n" 1068 << "uniform highp " << vecType << " u_color;\n" 1069 << "\n" 1070 << "void main (void)\n" 1071 << "{\n" 1072 << " const highp float threshold = 0.0005f;\n" 1073 << " bool valuesEqual = all(lessThan(abs(o_color - u_color), vec4(threshold)));\n\n" 1074 << " if (valuesEqual)\n" 1075 << " o_color += u_color;\n" 1076 << " else\n" 1077 << " discard;\n" 1078 << "}\n"; 1079 1080 return glu::makeVtxFragSources(genPassThroughVertSource(), fragShaderSource.str()); 1081 } 1082 1083 void FragmentDiscardTestCase::genFramebufferWithGrid (const tcu::Vec4& fbColorEven, const tcu::Vec4& fbColorOdd) 1084 { 1085 tcu::TextureLevel data (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 1086 1087 m_gl.genFramebuffers(1, &m_framebuffer); 1088 m_gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 1089 1090 m_gl.genTextures(1, &m_texColorBuffer); 1091 m_gl.bindTexture(GL_TEXTURE_2D, m_texColorBuffer); 1092 1093 tcu::fillWithGrid(data.getAccess(), 8, fbColorEven, fbColorOdd); 1094 1095 m_gl.texImage2D(GL_TEXTURE_2D, 0, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 0, m_transferFmt.format, m_transferFmt.dataType, data.getAccess().getDataPtr()); 1096 m_gl.bindTexture(GL_TEXTURE_2D, 0); 1097 1098 m_gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texColorBuffer, 0); 1099 TCU_CHECK(m_gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); 1100 } 1101 1102 tcu::TextureLevel FragmentDiscardTestCase::genReferenceTexture (const tcu::Vec4& fbColorEven, const tcu::Vec4& fbColorOdd) 1103 { 1104 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 1105 tcu::fillWithGrid(reference.getAccess(), 8, fbColorEven + fbColorEven, fbColorOdd); 1106 1107 return reference; 1108 } 1109 1110 FragmentDiscardTestCase::IterateResult FragmentDiscardTestCase::iterate (void) 1111 { 1112 const tcu::Vec4 fbColorEven = scaleColorValue(m_texFmt, tcu::Vec4(0.5f, 0.0f, 1.0f, 1.0f)); 1113 const tcu::Vec4 fbColorOdd = scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f)); 1114 1115 tcu::TextureLevel reference = genReferenceTexture(fbColorEven, fbColorOdd); 1116 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 1117 genFramebufferWithGrid(fbColorEven, fbColorOdd); 1118 1119 genUniformColor(fbColorEven); 1120 render(); 1121 1122 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 1123 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 1124 1125 return STOP; 1126 } 1127 1128 // Test description: 1129 // - Create 2D texture array containing three mipmaps. 1130 // - Each mipmap level is assigned a different color. 1131 // - Attach single mipmap level to framebuffer and draw full screen quad. 1132 // - Sum framebuffer read color with passed in uniform color. 1133 // - Compare resulting surface with reference. 1134 // - Repeat for subsequent mipmap levels. 1135 1136 class TextureLevelTestCase : public FramebufferFetchTestCase 1137 { 1138 public: 1139 TextureLevelTestCase (Context& context, const char* name, const char* desc, deUint32 format); 1140 ~TextureLevelTestCase (void) {} 1141 1142 IterateResult iterate (void); 1143 1144 private: 1145 void create2DTextureArrayMipMaps (const vector<tcu::Vec4>& colors); 1146 tcu::TextureLevel genReferenceTexture (int level, const vector<tcu::Vec4>& colors, const tcu::Vec4& uniformColor); 1147 void genReferenceMipmap (const tcu::Vec4& color, tcu::TextureLevel& reference); 1148 }; 1149 1150 TextureLevelTestCase::TextureLevelTestCase (Context& context, const char* name, const char* desc, deUint32 format) 1151 : FramebufferFetchTestCase(context, name, desc, format) 1152 { 1153 } 1154 1155 void TextureLevelTestCase::create2DTextureArrayMipMaps (const vector<tcu::Vec4>& colors) 1156 { 1157 int numLevels = (int)colors.size(); 1158 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType)); 1159 1160 m_gl.genTextures(1, &m_texColorBuffer); 1161 m_gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texColorBuffer); 1162 1163 m_gl.texImage3D(GL_TEXTURE_2D_ARRAY, 0, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1, 0, m_transferFmt.format, m_transferFmt.dataType, DE_NULL); 1164 m_gl.generateMipmap(GL_TEXTURE_2D_ARRAY); 1165 1166 for (int level = 0; level < numLevels; level++) 1167 { 1168 int levelW = de::max(1, VIEWPORT_WIDTH >> level); 1169 int levelH = de::max(1, VIEWPORT_HEIGHT >> level); 1170 1171 levelData.setSize(levelW, levelH, 1); 1172 1173 clear(levelData.getAccess(), colors[level]); 1174 m_gl.texImage3D(GL_TEXTURE_2D_ARRAY, level, m_format, levelW, levelH, 1, 0, m_transferFmt.format, m_transferFmt.dataType, levelData.getAccess().getDataPtr()); 1175 } 1176 1177 m_gl.bindTexture(GL_TEXTURE_2D_ARRAY, 0); 1178 GLU_EXPECT_NO_ERROR(m_gl.getError(), "create2DTextureArrayMipMaps()"); 1179 } 1180 1181 tcu::TextureLevel TextureLevelTestCase::genReferenceTexture (int level, const vector<tcu::Vec4>& colors, const tcu::Vec4& uniformColor) 1182 { 1183 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH >> level, VIEWPORT_HEIGHT >> level, 1); 1184 1185 genReferenceMipmap(colors[level] + uniformColor, reference); 1186 1187 return reference; 1188 } 1189 1190 void TextureLevelTestCase::genReferenceMipmap (const tcu::Vec4& color, tcu::TextureLevel& reference) 1191 { 1192 const int width = reference.getAccess().getWidth(); 1193 const int height = reference.getAccess().getHeight(); 1194 const int left = width / 2; 1195 const int top = height / 2; 1196 1197 clear(getSubregion(reference.getAccess(), left, 0, 0, width-left, top, 1), color); 1198 clear(getSubregion(reference.getAccess(), 0, top, 0, left, height-top, 1), color); 1199 clear(getSubregion(reference.getAccess(), left, top, 0, width-left, height-top, 1), color); 1200 clear(getSubregion(reference.getAccess(), 0, 0, 0, left, top, 1), color); 1201 } 1202 1203 TextureLevelTestCase::IterateResult TextureLevelTestCase::iterate (void) 1204 { 1205 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.1f, 0.0f, 0.0f, 1.0f)); 1206 vector<tcu::Vec4> levelColors; 1207 1208 levelColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.4f, 0.0f, 0.0f, 1.0f))); 1209 levelColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.2f, 0.0f, 0.0f, 1.0f))); 1210 levelColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f))); 1211 1212 m_gl.genFramebuffers(1, &m_framebuffer); 1213 m_gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 1214 1215 create2DTextureArrayMipMaps(levelColors); 1216 1217 // attach successive mipmap layers to framebuffer and render 1218 for (int level = 0; level < (int)levelColors.size(); ++level) 1219 { 1220 std::ostringstream name, desc; 1221 name << "Level " << level; 1222 desc << "Mipmap level " << level; 1223 1224 const tcu::ScopedLogSection section (m_testCtx.getLog(), name.str(), desc.str()); 1225 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH >> level, VIEWPORT_HEIGHT >> level); 1226 tcu::TextureLevel reference = genReferenceTexture(level, levelColors, uniformColor); 1227 1228 m_gl.framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texColorBuffer, level, 0); 1229 1230 genUniformColor(uniformColor); 1231 render(); 1232 1233 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 1234 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 1235 1236 if (m_testCtx.getTestResult() != QP_TEST_RESULT_PASS) 1237 return STOP; 1238 } 1239 1240 return STOP; 1241 } 1242 1243 class TextureLayerTestCase : public FramebufferFetchTestCase 1244 { 1245 public: 1246 TextureLayerTestCase (Context& context, const char* name, const char* desc, deUint32 format); 1247 ~TextureLayerTestCase (void) {} 1248 1249 IterateResult iterate (void); 1250 1251 private: 1252 void create2DTextureArrayLayers (const vector<tcu::Vec4>& colors); 1253 tcu::TextureLevel genReferenceTexture (int layer, const vector<tcu::Vec4>& colors, const tcu::Vec4& uniformColor); 1254 }; 1255 1256 TextureLayerTestCase::TextureLayerTestCase (Context& context, const char* name, const char* desc, deUint32 format) 1257 : FramebufferFetchTestCase(context, name, desc, format) 1258 { 1259 } 1260 1261 void TextureLayerTestCase::create2DTextureArrayLayers (const vector<tcu::Vec4>& colors) 1262 { 1263 int numLayers = (int)colors.size(); 1264 tcu::TextureLevel layerData (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType)); 1265 1266 m_gl.genTextures(1, &m_texColorBuffer); 1267 m_gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texColorBuffer); 1268 m_gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1, m_format, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, numLayers); 1269 m_gl.bindImageTexture(0, m_texColorBuffer, 0, GL_FALSE, 0, GL_READ_ONLY, m_format); 1270 1271 layerData.setSize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT, numLayers); 1272 1273 for (int layer = 0; layer < numLayers; layer++) 1274 { 1275 clear(layerData.getAccess(), colors[layer]); 1276 m_gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, layer, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1, m_transferFmt.format, m_transferFmt.dataType, layerData.getAccess().getDataPtr()); 1277 } 1278 1279 m_gl.bindTexture(GL_TEXTURE_2D_ARRAY, 0); 1280 GLU_EXPECT_NO_ERROR(m_gl.getError(), "create2DTextureArrayLayers()"); 1281 } 1282 1283 tcu::TextureLevel TextureLayerTestCase::genReferenceTexture (int layer, const vector<tcu::Vec4>& colors, const tcu::Vec4& uniformColor) 1284 { 1285 tcu::TextureLevel reference (glu::mapGLTransferFormat(m_transferFmt.format, m_transferFmt.dataType), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, 1); 1286 clear(reference.getAccess(), colors[layer] + uniformColor); 1287 1288 return reference; 1289 } 1290 1291 // Test description 1292 // - Create 2D texture array containing three layers. 1293 // - Each layer is assigned a different color. 1294 // - Attach single layer to framebuffer and draw full screen quad. 1295 // - Sum framebuffer read color with passed in uniform color. 1296 // - Compare resulting surface with reference. 1297 // - Repeat for subsequent texture layers. 1298 1299 TextureLayerTestCase::IterateResult TextureLayerTestCase::iterate (void) 1300 { 1301 const tcu::Vec4 uniformColor = scaleColorValue(m_texFmt, tcu::Vec4(0.1f, 0.1f, 0.1f, 1.0f)); 1302 tcu::TextureLevel result (getReadPixelFormat(m_texFmt), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); 1303 vector<tcu::Vec4> layerColors; 1304 1305 layerColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.4f, 0.0f, 0.0f, 1.0f))); 1306 layerColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.2f, 0.0f, 0.0f, 1.0f))); 1307 layerColors.push_back(scaleColorValue(m_texFmt, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f))); 1308 1309 m_gl.genFramebuffers(1, &m_framebuffer); 1310 m_gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 1311 1312 create2DTextureArrayLayers(layerColors); 1313 1314 for (int layer = 0; layer < (int)layerColors.size(); ++layer) 1315 { 1316 std::ostringstream name, desc; 1317 name << "Layer " << layer; 1318 desc << "Layer " << layer; 1319 1320 const tcu::ScopedLogSection section (m_testCtx.getLog(), name.str(), desc.str()); 1321 tcu::TextureLevel reference = genReferenceTexture(layer, layerColors, uniformColor); 1322 1323 m_gl.framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texColorBuffer, 0, layer); 1324 1325 genUniformColor(uniformColor); 1326 render(); 1327 1328 glu::readPixels(m_context.getRenderContext(), 0, 0, result.getAccess()); 1329 verifyRenderbuffer(m_testCtx.getLog(), m_texFmt, reference, result); 1330 1331 if (m_testCtx.getTestResult() != QP_TEST_RESULT_PASS) 1332 return STOP; 1333 } 1334 1335 return STOP; 1336 } 1337 1338 } // Anonymous 1339 1340 ShaderFramebufferFetchTests::ShaderFramebufferFetchTests (Context& context) 1341 : TestCaseGroup (context, "framebuffer_fetch", "GL_EXT_shader_framebuffer_fetch tests") 1342 { 1343 } 1344 1345 ShaderFramebufferFetchTests::~ShaderFramebufferFetchTests (void) 1346 { 1347 } 1348 1349 void ShaderFramebufferFetchTests::init (void) 1350 { 1351 tcu::TestCaseGroup* const basicTestGroup = new tcu::TestCaseGroup(m_testCtx, "basic", "Basic framebuffer shader fetch tests"); 1352 tcu::TestCaseGroup* const framebufferFormatTestGroup = new tcu::TestCaseGroup(m_testCtx, "framebuffer_format", "Texture render target formats tests"); 1353 1354 // basic 1355 { 1356 basicTestGroup->addChild(new TexelFetchTestCase (m_context, "texel_fetch", "Framebuffer fetches in conjunction with shader texel fetches", GL_RGBA8)); 1357 basicTestGroup->addChild(new LastFragDataTestCase (m_context, "last_frag_data", "Framebuffer fetches with built-in fragment output of ES 2.0", GL_RGBA8)); 1358 basicTestGroup->addChild(new FragmentDiscardTestCase (m_context, "fragment_discard", "Framebuffer fetches in combination with fragment discards", GL_RGBA8)); 1359 basicTestGroup->addChild(new MultipleAssignmentTestCase (m_context, "multiple_assignment", "Multiple assignments to fragment color inout", GL_RGBA8)); 1360 basicTestGroup->addChild(new MultipleRenderTargetsTestCase (m_context, "multiple_render_targets", "Framebuffer fetches used in combination with multiple render targets", GL_RGBA8)); 1361 basicTestGroup->addChild(new TextureLevelTestCase (m_context, "framebuffer_texture_level", "Framebuffer fetches with individual texture render target mipmaps", GL_RGBA8)); 1362 basicTestGroup->addChild(new TextureLayerTestCase (m_context, "framebuffer_texture_layer", "Framebuffer fetches with individual texture render target layers", GL_RGBA8)); 1363 } 1364 1365 // framebuffer formats 1366 { 1367 static const deUint32 colorFormats[] = 1368 { 1369 // RGBA formats 1370 GL_RGBA32I, 1371 GL_RGBA32UI, 1372 GL_RGBA16I, 1373 GL_RGBA16UI, 1374 GL_RGBA8, 1375 GL_RGBA8I, 1376 GL_RGBA8UI, 1377 GL_SRGB8_ALPHA8, 1378 GL_RGB10_A2, 1379 GL_RGB10_A2UI, GL_RGBA4, GL_RGB5_A1, 1380 1381 // RGB formats 1382 GL_RGB8, 1383 GL_RGB565, 1384 1385 // RG formats 1386 GL_RG32I, 1387 GL_RG32UI, 1388 GL_RG16I, 1389 GL_RG16UI, 1390 GL_RG8, 1391 GL_RG8I, 1392 GL_RG8UI, 1393 1394 // R formats 1395 GL_R32I, 1396 GL_R32UI, 1397 GL_R16I, 1398 GL_R16UI, 1399 GL_R8, 1400 GL_R8I, 1401 GL_R8UI, 1402 1403 // GL_EXT_color_buffer_float 1404 GL_RGBA32F, 1405 GL_RGBA16F, 1406 GL_R11F_G11F_B10F, 1407 GL_RG32F, 1408 GL_RG16F, 1409 GL_R32F, 1410 GL_R16F, 1411 1412 // GL_EXT_color_buffer_half_float 1413 GL_RGB16F 1414 }; 1415 1416 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++) 1417 framebufferFormatTestGroup->addChild(new TextureFormatTestCase(m_context, getFormatName(colorFormats[ndx]), "Framebuffer fetches from texture attachments with varying formats", colorFormats[ndx])); 1418 } 1419 1420 addChild(basicTestGroup); 1421 addChild(framebufferFormatTestGroup); 1422 } 1423 1424 } // Functional 1425 } // gles31 1426 } // deqp 1427
