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 GLES Scissor tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "glsScissorTests.hpp" 25 #include "glsTextureTestUtil.hpp" 26 27 #include "deMath.h" 28 #include "deRandom.hpp" 29 #include "deUniquePtr.hpp" 30 31 #include "tcuTestCase.hpp" 32 #include "tcuImageCompare.hpp" 33 #include "tcuVector.hpp" 34 #include "tcuVectorUtil.hpp" 35 #include "tcuTexture.hpp" 36 #include "tcuStringTemplate.hpp" 37 38 #include "gluStrUtil.hpp" 39 #include "gluDrawUtil.hpp" 40 #include "gluPixelTransfer.hpp" 41 #include "gluObjectWrapper.hpp" 42 43 #include "glwEnums.hpp" 44 #include "glwFunctions.hpp" 45 46 #include <map> 47 48 namespace deqp 49 { 50 namespace gls 51 { 52 namespace Functional 53 { 54 namespace 55 { 56 57 using namespace ScissorTestInternal; 58 using namespace glw; // GL types 59 60 using tcu::ConstPixelBufferAccess; 61 using tcu::PixelBufferAccess; 62 using tcu::TestLog; 63 64 using std::vector; 65 using std::string; 66 using std::map; 67 using tcu::Vec3; 68 using tcu::Vec4; 69 using tcu::IVec4; 70 using tcu::UVec4; 71 72 void drawQuad (const glw::Functions& gl, deUint32 program, const Vec3& p0, const Vec3& p1) 73 { 74 // Vertex data. 75 const float hz = (p0.z() + p1.z()) * 0.5f; 76 const float position[] = 77 { 78 p0.x(), p0.y(), p0.z(), 1.0f, 79 p0.x(), p1.y(), hz, 1.0f, 80 p1.x(), p0.y(), hz, 1.0f, 81 p1.x(), p1.y(), p1.z(), 1.0f 82 }; 83 84 const deUint16 indices[] = { 0, 1, 2, 2, 1, 3 }; 85 86 const deInt32 posLoc = gl.getAttribLocation(program, "a_position"); 87 88 gl.useProgram(program); 89 gl.enableVertexAttribArray(posLoc); 90 gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &position[0]); 91 92 gl.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0]); 93 94 gl.disableVertexAttribArray(posLoc); 95 96 } 97 98 void drawPrimitives (const glw::Functions& gl, deUint32 program, const deUint32 type, const vector<float>& vertices, const vector<deUint16>& indices) 99 { 100 const deInt32 posLoc = gl.getAttribLocation(program, "a_position"); 101 102 TCU_CHECK(posLoc >= 0); 103 104 gl.useProgram(program); 105 gl.enableVertexAttribArray(posLoc); 106 gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &vertices[0]); 107 108 gl.drawElements(type, GLsizei(indices.size()), GL_UNSIGNED_SHORT, &indices[0]); 109 110 gl.disableVertexAttribArray(posLoc); 111 } 112 113 template<typename T> 114 void clearEdges (const tcu::PixelBufferAccess& access, const T& color, const IVec4& scissorArea) 115 { 116 for (int y = 0; y < access.getHeight(); y++) 117 for (int x = 0; x < access.getWidth(); x++) 118 { 119 if (y < scissorArea.y() || 120 y >= scissorArea.y() + scissorArea.w() || 121 x < scissorArea.x() || 122 x >= scissorArea.x()+ scissorArea.z()) 123 access.setPixel(color, x, y); 124 } 125 } 126 127 glu::ProgramSources genShaders(glu::GLSLVersion version) 128 { 129 const string vtxSource = "${VERSION}\n" 130 "${IN} highp vec4 a_position;\n" 131 "void main(){\n" 132 " gl_Position = a_position;\n" 133 "}\n"; 134 135 const string frgSource = "${VERSION}\n" 136 "${OUT_DECL}" 137 "uniform highp vec4 u_color;\n" 138 "void main(){\n" 139 " ${OUTPUT} = u_color;\n" 140 "}\n"; 141 142 map<string, string> params; 143 144 switch(version) 145 { 146 case glu::GLSL_VERSION_100_ES: 147 params["VERSION"] = "#version 100"; 148 params["IN"] = "attribute"; 149 params["OUT_DECL"] = ""; 150 params["OUTPUT"] = "gl_FragColor"; 151 break; 152 153 case glu::GLSL_VERSION_300_ES: 154 case glu::GLSL_VERSION_310_ES: // Assumed to support 3.0 155 params["VERSION"] = "#version 300 es"; 156 params["IN"] = "in"; 157 params["OUT_DECL"] = "out mediump vec4 f_color;\n"; 158 params["OUTPUT"] = "f_color"; 159 break; 160 161 default: 162 DE_FATAL("Unsupported version"); 163 } 164 165 return glu::makeVtxFragSources(tcu::StringTemplate(vtxSource).specialize(params), tcu::StringTemplate(frgSource).specialize(params)); 166 } 167 168 // Wrapper class, provides iterator & reporting logic 169 class ScissorCase : public tcu::TestCase 170 { 171 public: 172 ScissorCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char *name, const char* desc, const Vec4& scissorArea); 173 virtual ~ScissorCase (void) {} 174 175 virtual IterateResult iterate (void); 176 177 protected: 178 virtual void render (GLuint program, const IVec4& viewport) const = 0; 179 180 glu::RenderContext& m_renderCtx; 181 const Vec4 m_scissorArea; 182 }; 183 184 ScissorCase::ScissorCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char *name, const char* desc, const Vec4& scissorArea) 185 : TestCase (testCtx, name, desc) 186 , m_renderCtx (renderCtx) 187 , m_scissorArea (scissorArea) 188 { 189 } 190 191 ScissorCase::IterateResult ScissorCase::iterate (void) 192 { 193 using TextureTestUtil::RandomViewport; 194 195 const glw::Functions& gl = m_renderCtx.getFunctions(); 196 TestLog& log = m_testCtx.getLog(); 197 const tcu::PixelFormat renderFormat = m_renderCtx.getRenderTarget().getPixelFormat(); 198 const tcu::Vec4 threshold = 0.02f * UVec4(1u << de::max(0, 8 - renderFormat.redBits), 199 1u << de::max(0, 8 - renderFormat.greenBits), 200 1u << de::max(0, 8 - renderFormat.blueBits), 201 1u << de::max(0, 8 - renderFormat.alphaBits)).asFloat(); 202 const glu::ShaderProgram shader (m_renderCtx, genShaders(glu::getContextTypeGLSLVersion(m_renderCtx.getType()))); 203 204 const RandomViewport viewport (m_renderCtx.getRenderTarget(), 256, 256, deStringHash(getName())); 205 const IVec4 relScissorArea (int(m_scissorArea.x() * (float)viewport.width), 206 int(m_scissorArea.y() * (float)viewport.height), 207 int(m_scissorArea.z() * (float)viewport.width), 208 int(m_scissorArea.w() * (float)viewport.height)); 209 const IVec4 absScissorArea (relScissorArea.x() + viewport.x, 210 relScissorArea.y() + viewport.y, 211 relScissorArea.z(), 212 relScissorArea.w()); 213 214 tcu::Surface refImage (viewport.width, viewport.height); 215 tcu::Surface resImage (viewport.width, viewport.height); 216 217 if (!shader.isOk()) 218 { 219 log << shader; 220 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader compile/link failed"); 221 return STOP; 222 } 223 224 log << TestLog::Message << "Viewport area is " << IVec4(viewport.x, viewport.y, viewport.width, viewport.height) << TestLog::EndMessage; 225 log << TestLog::Message << "Scissor area is " << absScissorArea << TestLog::EndMessage; 226 227 // Render reference (no scissors) 228 { 229 log << TestLog::Message << "Rendering reference (scissors disabled)" << TestLog::EndMessage; 230 231 gl.useProgram(shader.getProgram()); 232 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 233 234 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 235 gl.clearDepthf(1.0f); 236 gl.clearStencil(0); 237 gl.disable(GL_DEPTH_TEST); 238 gl.disable(GL_STENCIL_TEST); 239 gl.disable(GL_SCISSOR_TEST); 240 gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); 241 242 render(shader.getProgram(), IVec4(viewport.x, viewport.y, viewport.width, viewport.height)); 243 244 glu::readPixels(m_renderCtx, viewport.x, viewport.y, refImage.getAccess()); 245 GLU_CHECK_ERROR(gl.getError()); 246 } 247 248 // Render result (scissors) 249 { 250 log << TestLog::Message << "Rendering result (scissors enabled)" << TestLog::EndMessage; 251 252 gl.useProgram(shader.getProgram()); 253 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 254 255 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 256 gl.clearDepthf(1.0f); 257 gl.clearStencil(0); 258 gl.disable(GL_DEPTH_TEST); 259 gl.disable(GL_STENCIL_TEST); 260 gl.disable(GL_SCISSOR_TEST); 261 gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); 262 263 gl.scissor(absScissorArea.x(), absScissorArea.y(), absScissorArea.z(), absScissorArea.w()); 264 gl.enable(GL_SCISSOR_TEST); 265 266 render(shader.getProgram(), IVec4(viewport.x, viewport.y, viewport.width, viewport.height)); 267 268 glu::readPixels(m_renderCtx, viewport.x, viewport.y, resImage.getAccess()); 269 GLU_CHECK_ERROR(gl.getError()); 270 } 271 272 // Manual 'scissors' for reference image 273 log << TestLog::Message << "Clearing area outside scissor area from reference" << TestLog::EndMessage; 274 clearEdges(refImage.getAccess(), IVec4(32, 64, 128, 255), relScissorArea); 275 276 if (tcu::floatThresholdCompare(log, "ComparisonResult", "Image comparison result", refImage.getAccess(), resImage.getAccess(), threshold, tcu::COMPARE_LOG_RESULT)) 277 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 278 else 279 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 280 281 return STOP; 282 } 283 284 // Tests scissoring with multiple primitive types 285 class ScissorPrimitiveCase : public ScissorCase 286 { 287 public: 288 ScissorPrimitiveCase (tcu::TestContext& testCtx, 289 glu::RenderContext& renderCtx, 290 const char* name, 291 const char* desc, 292 const Vec4& scissorArea, 293 const Vec4& renderArea, 294 PrimitiveType type, 295 int primitiveCount); 296 virtual ~ScissorPrimitiveCase (void){} 297 298 protected: 299 virtual void render (GLuint program, const IVec4& viewport) const; 300 301 private: 302 const Vec4 m_renderArea; 303 const PrimitiveType m_primitiveType; 304 const int m_primitiveCount; 305 }; 306 307 ScissorPrimitiveCase::ScissorPrimitiveCase (tcu::TestContext& testCtx, 308 glu::RenderContext& renderCtx, 309 const char* name, 310 const char* desc, 311 const Vec4& scissorArea, 312 const Vec4& renderArea, 313 PrimitiveType type, 314 int primitiveCount) 315 : ScissorCase (testCtx, renderCtx, name, desc, scissorArea) 316 , m_renderArea (renderArea) 317 , m_primitiveType (type) 318 , m_primitiveCount (primitiveCount) 319 { 320 } 321 322 void ScissorPrimitiveCase::render (GLuint program, const IVec4&) const 323 { 324 const glw::Functions& gl = m_renderCtx.getFunctions(); 325 const Vec4 white (1.0f, 1.0f, 1.0f, 1.0); 326 const Vec4 primitiveArea (m_renderArea.x()*2.0f-1.0f, 327 m_renderArea.x()*2.0f-1.0f, 328 m_renderArea.z()*2.0f, 329 m_renderArea.w()*2.0f); 330 331 static const float quadPositions[] = 332 { 333 0.0f, 1.0f, 334 0.0f, 0.0f, 335 1.0f, 1.0f, 336 1.0f, 0.0f 337 }; 338 static const float triPositions[] = 339 { 340 0.0f, 0.0f, 341 1.0f, 0.0f, 342 0.5f, 1.0f, 343 }; 344 static const float linePositions[] = 345 { 346 0.0f, 0.0f, 347 1.0f, 1.0f 348 }; 349 static const float pointPosition[] = 350 { 351 0.5f, 0.5f 352 }; 353 354 const float* positionSet[] = { pointPosition, linePositions, triPositions, quadPositions }; 355 const int vertexCountSet[]= { 1, 2, 3, 4 }; 356 const int indexCountSet[] = { 1, 2, 3, 6 }; 357 358 const deUint16 baseIndices[] = { 0, 1, 2, 2, 1, 3 }; 359 const float* basePositions = positionSet[m_primitiveType]; 360 const int vertexCount = vertexCountSet[m_primitiveType]; 361 const int indexCount = indexCountSet[m_primitiveType]; 362 363 const float scale = 1.44f/deFloatSqrt(float(m_primitiveCount)*2.0f); // Magic value to roughly fill the render area with primitives at a readable density 364 vector<float> positions (4*vertexCount*m_primitiveCount); 365 vector<deUint16> indices (indexCount*m_primitiveCount); 366 de::Random rng (1234); 367 368 for (int primNdx = 0; primNdx < m_primitiveCount; primNdx++) 369 { 370 const float dx = m_primitiveCount>1 ? rng.getFloat() : 0.0f; 371 const float dy = m_primitiveCount>1 ? rng.getFloat() : 0.0f; 372 373 for (int vertNdx = 0; vertNdx < vertexCount; vertNdx++) 374 { 375 const int ndx = primNdx*4*vertexCount + vertNdx*4; 376 positions[ndx+0] = (basePositions[vertNdx*2 + 0]*scale + dx)*primitiveArea.z() + primitiveArea.x(); 377 positions[ndx+1] = (basePositions[vertNdx*2 + 1]*scale + dy)*primitiveArea.w() + primitiveArea.y(); 378 positions[ndx+2] = 0.2f; 379 positions[ndx+3] = 1.0f; 380 } 381 382 for (int ndx = 0; ndx < indexCount; ndx++) 383 indices[primNdx*indexCount + ndx] = (deUint16)(baseIndices[ndx] + primNdx*vertexCount); 384 } 385 386 gl.uniform4fv(gl.getUniformLocation(program, "u_color"), 1, white.m_data); 387 388 switch (m_primitiveType) 389 { 390 case TRIANGLE: drawPrimitives(gl, program, GL_TRIANGLES, positions, indices); break; 391 case LINE: drawPrimitives(gl, program, GL_LINES, positions, indices); break; 392 case POINT: drawPrimitives(gl, program, GL_POINTS, positions, indices); break; 393 default: DE_ASSERT(false); break; 394 } 395 } 396 397 // Test effect of scissor on default framebuffer clears 398 class ScissorClearCase : public ScissorCase 399 { 400 public: 401 ScissorClearCase (tcu::TestContext& testCtx, 402 glu::RenderContext& renderCtx, 403 const char* name, 404 const char* desc, 405 const Vec4& scissorArea, 406 deUint32 clearMode); 407 virtual ~ScissorClearCase (void) {} 408 409 virtual void init (void); 410 411 protected: 412 virtual void render (GLuint program, const IVec4& viewport) const; 413 414 private: 415 const deUint32 m_clearMode; //!< Combination of the flags accepted by glClear 416 }; 417 418 ScissorClearCase::ScissorClearCase (tcu::TestContext& testCtx, 419 glu::RenderContext& renderCtx, 420 const char* name, 421 const char* desc, 422 const Vec4& scissorArea, 423 deUint32 clearMode) 424 : ScissorCase (testCtx, renderCtx, name, desc, scissorArea) 425 , m_clearMode (clearMode) 426 { 427 } 428 429 void ScissorClearCase::init (void) 430 { 431 if ((m_clearMode & GL_DEPTH_BUFFER_BIT) && m_renderCtx.getRenderTarget().getDepthBits() == 0) 432 throw tcu::NotSupportedError("Cannot clear depth; no depth buffer present", "", __FILE__, __LINE__); 433 else if ((m_clearMode & GL_STENCIL_BUFFER_BIT) && m_renderCtx.getRenderTarget().getStencilBits() == 0) 434 throw tcu::NotSupportedError("Cannot clear stencil; no stencil buffer present", "", __FILE__, __LINE__); 435 } 436 437 void ScissorClearCase::render (GLuint program, const IVec4&) const 438 { 439 const glw::Functions& gl = m_renderCtx.getFunctions(); 440 const Vec4 white (1.0f, 1.0f, 1.0f, 1.0); 441 442 gl.clearColor(0.6f, 0.1f, 0.1f, 1.0); 443 gl.clearDepthf(0.0f); 444 445 if (m_clearMode & GL_DEPTH_BUFFER_BIT) 446 { 447 gl.enable(GL_DEPTH_TEST); 448 gl.depthFunc(GL_GREATER); 449 } 450 451 if (m_clearMode & GL_STENCIL_BUFFER_BIT) 452 { 453 gl.clearStencil(123); 454 gl.enable(GL_STENCIL_TEST); 455 gl.stencilFunc(GL_EQUAL, 123, ~0u); 456 } 457 458 if (m_clearMode & GL_COLOR_BUFFER_BIT) 459 gl.clearColor(0.1f, 0.6f, 0.1f, 1.0); 460 461 gl.clear(m_clearMode); 462 gl.disable(GL_SCISSOR_TEST); 463 464 gl.uniform4fv(gl.getUniformLocation(program, "u_color"), 1, white.getPtr()); 465 466 if (!(m_clearMode & GL_COLOR_BUFFER_BIT)) 467 drawQuad(gl, program, Vec3(-1.0f, -1.0f, 0.5f), Vec3(1.0f, 1.0f, 0.5f)); 468 469 gl.disable(GL_DEPTH_TEST); 470 gl.disable(GL_STENCIL_TEST); 471 } 472 473 class FramebufferBlitCase : public ScissorCase 474 { 475 public: 476 FramebufferBlitCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* desc, const Vec4& scissorArea); 477 virtual ~FramebufferBlitCase (void) {} 478 479 virtual void init (void); 480 virtual void deinit (void); 481 482 protected: 483 typedef de::MovePtr<glu::Framebuffer> FramebufferP; 484 485 enum {SIZE = 64}; 486 487 virtual void render (GLuint program, const IVec4& viewport) const; 488 489 FramebufferP m_fbo; 490 }; 491 492 FramebufferBlitCase::FramebufferBlitCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* desc, const Vec4& scissorArea) 493 : ScissorCase(testCtx, renderCtx, name, desc, scissorArea) 494 { 495 } 496 497 void FramebufferBlitCase::init (void) 498 { 499 if (m_renderCtx.getRenderTarget().getNumSamples()) 500 throw tcu::NotSupportedError("Cannot blit to multisampled framebuffer", "", __FILE__, __LINE__); 501 502 const glw::Functions& gl = m_renderCtx.getFunctions(); 503 const glu::Renderbuffer colorbuf (gl); 504 const tcu::Vec4 clearColor (1.0f, 0.5, 0.125f, 1.0f); 505 506 m_fbo = FramebufferP(new glu::Framebuffer(gl)); 507 508 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, **m_fbo); 509 510 gl.bindRenderbuffer(GL_RENDERBUFFER, *colorbuf); 511 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, SIZE, SIZE); 512 gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorbuf); 513 514 gl.clearBufferfv(GL_COLOR, 0, clearColor.getPtr()); 515 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_renderCtx.getDefaultFramebuffer()); 516 } 517 518 void FramebufferBlitCase::deinit (void) 519 { 520 m_fbo.clear(); 521 } 522 523 void FramebufferBlitCase::render(GLuint program, const IVec4& viewport) const 524 { 525 const glw::Functions& gl = m_renderCtx.getFunctions(); 526 527 const int width = viewport.z(); 528 const int height = viewport.w(); 529 const deInt32 defaultFramebuffer = m_renderCtx.getDefaultFramebuffer(); 530 531 DE_UNREF(program); 532 533 // blit to default framebuffer 534 gl.bindFramebuffer(GL_READ_FRAMEBUFFER, **m_fbo); 535 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, defaultFramebuffer); 536 537 gl.blitFramebuffer(0, 0, SIZE, SIZE, viewport.x(), viewport.y(), viewport.x() + width, viewport.y() + height, GL_COLOR_BUFFER_BIT, GL_NEAREST); 538 539 gl.bindFramebuffer(GL_READ_FRAMEBUFFER, defaultFramebuffer); 540 } 541 542 struct BufferFmtDesc 543 { 544 tcu::TextureFormat texFmt; 545 GLenum colorFmt; 546 }; 547 548 struct Color 549 { 550 enum Type {FLOAT, INT, UINT}; 551 552 Type type; 553 554 union 555 { 556 float f[4]; 557 deInt32 i[4]; 558 deUint32 u[4]; 559 }; 560 561 Color(const float f_[4]) : type(FLOAT) { f[0] = f_[0]; f[1] = f_[1]; f[2] = f_[2]; f[3] = f_[3]; } 562 Color(const deInt32 i_[4]) : type(INT) { i[0] = i_[0]; i[1] = i_[1]; i[2] = i_[2]; i[3] = i_[3]; } 563 Color(const deUint32 u_[4]) : type(UINT) { u[0] = u_[0]; u[1] = u_[1]; u[2] = u_[2]; u[3] = u_[3]; } 564 }; 565 566 class FramebufferClearCase : public tcu::TestCase 567 { 568 public: 569 FramebufferClearCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* desc, ClearType clearType); 570 virtual ~FramebufferClearCase (void) {} 571 572 virtual IterateResult iterate (void); 573 574 private: 575 static void clearBuffers (const glw::Functions& gl, Color color, float depth, int stencil); 576 static Color getBaseColor (const BufferFmtDesc& bufferFmt); 577 static Color getMainColor (const BufferFmtDesc& bufferFmt); 578 static BufferFmtDesc getBufferFormat (ClearType type); 579 580 virtual void render (GLuint program) const; 581 582 glu::RenderContext& m_renderCtx; 583 const ClearType m_clearType; 584 }; 585 586 FramebufferClearCase::FramebufferClearCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* desc, ClearType clearType) 587 : tcu::TestCase (testCtx, name, desc) 588 , m_renderCtx (renderCtx) 589 , m_clearType (clearType) 590 { 591 } 592 593 void FramebufferClearCase::clearBuffers (const glw::Functions& gl, Color color, float depth, int stencil) 594 { 595 switch(color.type) 596 { 597 case Color::FLOAT: gl.clearBufferfv (GL_COLOR, 0, color.f); break; 598 case Color::INT: gl.clearBufferiv (GL_COLOR, 0, color.i); break; 599 case Color::UINT: gl.clearBufferuiv(GL_COLOR, 0, color.u); break; 600 default: 601 DE_ASSERT(false); 602 } 603 604 gl.clearBufferfv(GL_DEPTH, 0, &depth); 605 gl.clearBufferiv(GL_STENCIL, 0, &stencil); 606 } 607 608 FramebufferClearCase::IterateResult FramebufferClearCase::iterate (void) 609 { 610 TestLog& log = m_testCtx.getLog(); 611 const glw::Functions& gl = m_renderCtx.getFunctions(); 612 const glu::ShaderProgram shader (m_renderCtx, genShaders(glu::getContextTypeGLSLVersion(m_renderCtx.getType()))); 613 614 const glu::Framebuffer fbo (gl); 615 const glu::Renderbuffer colorbuf (gl); 616 const glu::Renderbuffer depthbuf (gl); 617 618 const BufferFmtDesc bufferFmt = getBufferFormat(m_clearType); 619 const Color baseColor = getBaseColor(bufferFmt); 620 621 const int width = 64; 622 const int height = 64; 623 624 const IVec4 scissorArea (8, 8, 48, 48); 625 626 vector<deUint8> refData (width*height*bufferFmt.texFmt.getPixelSize()); 627 vector<deUint8> resData (width*height*bufferFmt.texFmt.getPixelSize()); 628 629 tcu::PixelBufferAccess refAccess (bufferFmt.texFmt, width, height, 1, &refData[0]); 630 tcu::PixelBufferAccess resAccess (bufferFmt.texFmt, width, height, 1, &resData[0]); 631 632 if (!shader.isOk()) 633 { 634 log << shader; 635 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader compile/link failed"); 636 return STOP; 637 } 638 639 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, *fbo); 640 gl.bindFramebuffer(GL_READ_FRAMEBUFFER, *fbo); 641 642 // Color 643 gl.bindRenderbuffer(GL_RENDERBUFFER, *colorbuf); 644 gl.renderbufferStorage(GL_RENDERBUFFER, bufferFmt.colorFmt, width, height); 645 gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorbuf); 646 647 // Depth/stencil 648 gl.bindRenderbuffer(GL_RENDERBUFFER, *depthbuf); 649 gl.renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height); 650 gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, *depthbuf); 651 652 log << TestLog::Message << "Scissor area is " << scissorArea << TestLog::EndMessage; 653 654 // Render reference 655 { 656 log << TestLog::Message << "Rendering reference (scissors disabled)" << TestLog::EndMessage; 657 658 gl.useProgram(shader.getProgram()); 659 gl.viewport(0, 0, width, height); 660 661 gl.disable(GL_DEPTH_TEST); 662 gl.disable(GL_STENCIL_TEST); 663 gl.disable(GL_SCISSOR_TEST); 664 665 clearBuffers(gl, baseColor, 1.0f, 0); 666 667 render(shader.getProgram()); 668 669 glu::readPixels(m_renderCtx, 0, 0, refAccess); 670 GLU_CHECK_ERROR(gl.getError()); 671 } 672 673 // Render result 674 { 675 log << TestLog::Message << "Rendering result (scissors enabled)" << TestLog::EndMessage; 676 677 gl.useProgram(shader.getProgram()); 678 gl.viewport(0, 0, width, height); 679 680 gl.disable(GL_DEPTH_TEST); 681 gl.disable(GL_STENCIL_TEST); 682 gl.disable(GL_SCISSOR_TEST); 683 684 clearBuffers(gl, baseColor, 1.0f, 0); 685 686 gl.enable(GL_SCISSOR_TEST); 687 gl.scissor(scissorArea.x(), scissorArea.y(), scissorArea.z(), scissorArea.w()); 688 689 render(shader.getProgram()); 690 691 glu::readPixels(m_renderCtx, 0, 0, resAccess); 692 GLU_CHECK_ERROR(gl.getError()); 693 } 694 695 { 696 bool resultOk = false; 697 698 switch (baseColor.type) 699 { 700 case Color::FLOAT: 701 clearEdges(refAccess, Vec4(baseColor.f[0], baseColor.f[1], baseColor.f[2], baseColor.f[3]), scissorArea); 702 resultOk = tcu::floatThresholdCompare(log, "ComparisonResult", "Image comparison result", refAccess, resAccess, Vec4(0.02f, 0.02f, 0.02f, 0.02f), tcu::COMPARE_LOG_RESULT); 703 break; 704 705 case Color::INT: 706 clearEdges(refAccess, IVec4(baseColor.i[0], baseColor.i[1], baseColor.i[2], baseColor.i[3]), scissorArea); 707 resultOk = tcu::intThresholdCompare(log, "ComparisonResult", "Image comparison result", refAccess, resAccess, UVec4(2, 2, 2, 2), tcu::COMPARE_LOG_RESULT); 708 break; 709 710 case Color::UINT: 711 clearEdges(refAccess, UVec4(baseColor.u[0], baseColor.u[1], baseColor.u[2], baseColor.u[3]), scissorArea); 712 resultOk = tcu::intThresholdCompare(log, "ComparisonResult", "Image comparison result", refAccess, resAccess, UVec4(2, 2, 2, 2), tcu::COMPARE_LOG_RESULT); 713 break; 714 } 715 716 if (resultOk) 717 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 718 else 719 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 720 } 721 722 return STOP; 723 } 724 725 Color FramebufferClearCase::getBaseColor (const BufferFmtDesc& bufferFmt) 726 { 727 const float f[4] = {0.125f, 0.25f, 0.5f, 1.0f}; 728 const deInt32 i[4] = {0, 0, 0, 0}; 729 const deUint32 u[4] = {0, 0, 0, 0}; 730 731 switch(bufferFmt.colorFmt) 732 { 733 case GL_RGBA8: return Color(f); 734 case GL_RGBA8I: return Color(i); 735 case GL_RGBA8UI: return Color(u); 736 default: 737 DE_ASSERT(false); 738 } 739 740 return Color(f); 741 } 742 743 Color FramebufferClearCase::getMainColor (const BufferFmtDesc& bufferFmt) 744 { 745 const float f[4] = {1.0f, 1.0f, 0.5f, 1.0f}; 746 const deInt32 i[4] = {127, -127, 0, 127}; 747 const deUint32 u[4] = {255, 255, 0, 255}; 748 749 switch(bufferFmt.colorFmt) 750 { 751 case GL_RGBA8: return Color(f); 752 case GL_RGBA8I: return Color(i); 753 case GL_RGBA8UI: return Color(u); 754 default: 755 DE_ASSERT(false); 756 } 757 758 return Color(f); 759 } 760 761 BufferFmtDesc FramebufferClearCase::getBufferFormat (ClearType type) 762 { 763 BufferFmtDesc retval; 764 765 switch (type) 766 { 767 case CLEAR_COLOR_FLOAT: 768 retval.colorFmt = GL_RGBA16F; 769 retval.texFmt = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT); 770 DE_FATAL("Floating point clear not implemented");// \todo [2014-1-23 otto] pixel read format & type, nothing guaranteed, need extension... 771 break; 772 773 case CLEAR_COLOR_INT: 774 retval.colorFmt = GL_RGBA8I; 775 retval.texFmt = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32); 776 break; 777 778 case CLEAR_COLOR_UINT: 779 retval.colorFmt = GL_RGBA8UI; 780 retval.texFmt = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32); 781 break; 782 783 default: 784 retval.colorFmt = GL_RGBA8; 785 retval.texFmt = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8); 786 break; 787 } 788 789 return retval; 790 } 791 792 void FramebufferClearCase::render (GLuint program) const 793 { 794 const glw::Functions& gl = m_renderCtx.getFunctions(); 795 796 const BufferFmtDesc bufferFmt = getBufferFormat(m_clearType); 797 const Color clearColor = getMainColor(bufferFmt); 798 799 const int clearStencil = 123; 800 const float clearDepth = 0.5f; 801 802 switch (m_clearType) 803 { 804 case CLEAR_COLOR_FIXED: gl.clearBufferfv (GL_COLOR, 0, clearColor.f); break; 805 case CLEAR_COLOR_FLOAT: gl.clearBufferfv (GL_COLOR, 0, clearColor.f); break; 806 case CLEAR_COLOR_INT: gl.clearBufferiv (GL_COLOR, 0, clearColor.i); break; 807 case CLEAR_COLOR_UINT: gl.clearBufferuiv(GL_COLOR, 0, clearColor.u); break; 808 case CLEAR_DEPTH: gl.clearBufferfv (GL_DEPTH, 0, &clearDepth); break; 809 case CLEAR_STENCIL: gl.clearBufferiv (GL_STENCIL, 0, &clearStencil); break; 810 case CLEAR_DEPTH_STENCIL: gl.clearBufferfi (GL_DEPTH_STENCIL, 0, clearDepth, clearStencil); break; 811 812 default: 813 DE_ASSERT(false); 814 } 815 816 const bool useDepth = (m_clearType == CLEAR_DEPTH || m_clearType == CLEAR_DEPTH_STENCIL); 817 const bool useStencil = (m_clearType == CLEAR_STENCIL || m_clearType == CLEAR_DEPTH_STENCIL); 818 819 // Render something to expose changes to depth/stencil buffer 820 if (useDepth || useStencil) 821 { 822 if (useDepth) 823 gl.enable(GL_DEPTH_TEST); 824 825 if (useStencil) 826 gl.enable(GL_STENCIL_TEST); 827 828 gl.stencilFunc(GL_EQUAL, clearStencil, ~0u); 829 gl.depthFunc(GL_GREATER); 830 gl.disable(GL_SCISSOR_TEST); 831 832 gl.uniform4fv(gl.getUniformLocation(program, "u_color"), 1, clearColor.f); 833 drawQuad(gl, program, tcu::Vec3(-1.0f, -1.0f, 0.6f), tcu::Vec3(1.0f, 1.0f, 0.6f)); 834 } 835 } 836 837 } // Anonymous 838 839 namespace ScissorTestInternal 840 { 841 842 tcu::TestNode* createPrimitiveTest (tcu::TestContext& testCtx, 843 glu::RenderContext& renderCtx, 844 const char* name, 845 const char* desc, 846 const Vec4& scissorArea, 847 const Vec4& renderArea, 848 PrimitiveType type, 849 int primitiveCount) 850 { 851 return new ScissorPrimitiveCase(testCtx, renderCtx, name, desc, scissorArea, renderArea, type, primitiveCount); 852 } 853 854 tcu::TestNode* createClearTest (tcu::TestContext& testCtx, 855 glu::RenderContext& renderCtx, 856 const char* name, 857 const char* desc, 858 const Vec4& scissorArea, 859 deUint32 clearMode) 860 { 861 return new ScissorClearCase(testCtx, renderCtx, name, desc, scissorArea, clearMode); 862 } 863 864 tcu::TestNode* createFramebufferClearTest (tcu::TestContext& testCtx, 865 glu::RenderContext& renderCtx, 866 const char* name, 867 const char* desc, 868 ClearType clearType) 869 { 870 return new FramebufferClearCase(testCtx, renderCtx, name, desc, clearType); 871 } 872 873 tcu::TestNode* createFramebufferBlitTest (tcu::TestContext& testCtx, 874 glu::RenderContext& renderCtx, 875 const char* name, 876 const char* desc, 877 const Vec4& scissorArea) 878 { 879 return new FramebufferBlitCase(testCtx, renderCtx, name, desc, scissorArea); 880 } 881 882 } // ScissorTestInternal 883 } // Functional 884 } // gls 885 } // deqp 886
