modules/gles2/functional/es2fPolygonOffsetTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.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 Polygon offset tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fPolygonOffsetTests.hpp"
  25 #include "deStringUtil.hpp"
  26 #include "deRandom.hpp"
  27 #include "gluContextInfo.hpp"
  28 #include "gluRenderContext.hpp"
  29 #include "gluShaderProgram.hpp"
  30 #include "gluPixelTransfer.hpp"
  31 #include "gluStrUtil.hpp"
  32 #include "glwEnums.hpp"
  33 #include "glwDefs.hpp"
  34 #include "glwFunctions.hpp"
  35 #include "tcuTestContext.hpp"
  36 #include "tcuTestLog.hpp"
  37 #include "tcuTextureUtil.hpp"
  38 #include "tcuRenderTarget.hpp"
  39 #include "tcuVectorUtil.hpp"
  40 #include "rrRenderer.hpp"
  41 #include "rrFragmentOperations.hpp"
  42
  43 #include "sglrReferenceContext.hpp"
  44
  45 #include <string>
  46 #include <limits>
  47
  48 using namespace glw; // GLint and other GL types
  49
  50 namespace deqp
  51 {
  52 namespace gles2
  53 {
  54 namespace Functional
  55 {
  56 namespace
  57 {
  58
  59 const char* s_shaderSourceVertex        = "attribute highp vec4 a_position;\n"
  60                                                                           "attribute highp vec4 a_color;\n"
  61                                                                           "varying mediump vec4 v_color;\n"
  62                                                                           "void main (void)\n"
  63                                                                           "{\n"
  64                                                                           "     gl_Position = a_position;\n"
  65                                                                           "     v_color = a_color;\n"
  66                                                                           "}\n";
  67 const char* s_shaderSourceFragment      = "varying mediump vec4 v_color;\n"
  68                                                                           "void main (void)\n"
  69                                                                           "{\n"
  70                                                                           "     gl_FragColor = v_color;\n"
  71                                                                           "}\n";
  72
  73 static const tcu::Vec4  MASK_COLOR_OK   = tcu::Vec4(0.0f, 0.1f, 0.0f, 1.0f);
  74 static const tcu::Vec4  MASK_COLOR_DEV  = tcu::Vec4(0.8f, 0.5f, 0.0f, 1.0f);
  75 static const tcu::Vec4  MASK_COLOR_FAIL = tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f);
  76
  77 inline bool compareThreshold (const tcu::IVec4& a, const tcu::IVec4& b, const tcu::IVec4& threshold)
  78 {
  79         return tcu::boolAll(tcu::lessThanEqual(tcu::abs(a - b), threshold));
  80 }
  81
  82 /*--------------------------------------------------------------------*//*!
  83 * \brief Pixelwise comparison of two images.
  84 * \note copied & modified from glsRasterizationTests
  85 *
  86 * Kernel radius defines maximum allowed distance. If radius is 0, only
  87 * perfect match is allowed. Radius of 1 gives a 3x3 kernel.
  88 *
  89 * Return values: -1 = Perfect match
  90 * 0 = Deviation within kernel
  91 * >0 = Number of faulty pixels
  92 *//*--------------------------------------------------------------------*/
  93 int compareImages (tcu::TestLog& log, glu::RenderContext& renderCtx, const tcu::ConstPixelBufferAccess& test, const tcu::ConstPixelBufferAccess& ref, const tcu::PixelBufferAccess& diffMask, int radius)
  94 {
  95         const int                       height                  = test.getHeight();
  96         const int                       width                   = test.getWidth();
  97         const int                       colorThreshold  = 128;
  98         const tcu::RGBA         formatThreshold = renderCtx.getRenderTarget().getPixelFormat().getColorThreshold();
  99         const tcu::IVec4        threshold               = tcu::IVec4(colorThreshold, colorThreshold, colorThreshold, formatThreshold.getAlpha() > 0 ? colorThreshold : 0)
 100                                                                                 + tcu::IVec4(formatThreshold.getRed(), formatThreshold.getGreen(), formatThreshold.getBlue(), formatThreshold.getAlpha());
 101
 102         int                     deviatingPixels = 0;
 103         int                     faultyPixels    = 0;
 104         int                     compareFailed   = -1;
 105
 106         tcu::clear(diffMask, MASK_COLOR_OK);
 107
 108         for (int y = 0; y < height; y++)
 109         {
 110                 for (int x = 0; x < width; x++)
 111                 {
 112                         const tcu::IVec4 cRef = ref.getPixelInt(x, y);
 113
 114                         // Pixelwise match, no deviation or fault
 115                         {
 116                                 const tcu::IVec4 cTest = test.getPixelInt(x, y);
 117                                 if (compareThreshold(cRef, cTest, threshold))
 118                                         continue;
 119                         }
 120
 121                         // If not, search within kernel radius
 122                         {
 123                                 const int kYmin = deMax32(y - radius, 0);
 124                                 const int kYmax = deMin32(y + radius, height-1);
 125                                 const int kXmin = deMax32(x - radius, 0);
 126                                 const int kXmax = deMin32(x + radius, width-1);
 127                                 bool found = false;
 128
 129                                 for (int kY = kYmin; kY <= kYmax; kY++)
 130                                 for (int kX = kXmin; kX <= kXmax; kX++)
 131                                 {
 132                                         const tcu::IVec4 cTest = test.getPixelInt(kX, kY);
 133                                         if (compareThreshold(cRef, cTest, threshold))
 134                                                 found = true;
 135                                 }
 136
 137                                 if (found)      // The pixel is deviating if the color is found inside the kernel
 138                                 {
 139                                         diffMask.setPixel(MASK_COLOR_DEV, x, y);
 140                                         if (compareFailed == -1)
 141                                                 compareFailed = 0;
 142                                         deviatingPixels++;
 143                                         continue;
 144                                 }
 145                         }
 146
 147                         diffMask.setPixel(MASK_COLOR_FAIL, x, y);
 148                         faultyPixels++;                                                                         // The pixel is faulty if the color is not found
 149                         compareFailed = 1;
 150                 }
 151         }
 152
 153         log << tcu::TestLog::Message << faultyPixels << " faulty pixel(s) found." << tcu::TestLog::EndMessage;
 154
 155         return (compareFailed == 1 ? faultyPixels : compareFailed);
 156 }
 157
 158 void verifyImages (tcu::TestLog& log, tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const tcu::ConstPixelBufferAccess& testImage, const tcu::ConstPixelBufferAccess& referenceImage)
 159 {
 160         using tcu::TestLog;
 161
 162         const int                       kernelRadius            = 1;
 163         const int                       faultyPixelLimit        = 20;
 164         int                                     faultyPixels;
 165         tcu::Surface            diffMask                        (testImage.getWidth(), testImage.getHeight());
 166
 167         faultyPixels = compareImages(log, renderCtx, referenceImage, testImage, diffMask.getAccess(), kernelRadius);
 168
 169         if (faultyPixels > faultyPixelLimit)
 170         {
 171                 log << TestLog::ImageSet("Images", "Image comparison");
 172                 log << TestLog::Image("Test image", "Test image", testImage);
 173                 log << TestLog::Image("Reference image", "Reference image", referenceImage);
 174                 log << TestLog::Image("Difference mask", "Difference mask", diffMask.getAccess());
 175                 log << TestLog::EndImageSet;
 176
 177                 log << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage;
 178                 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels");
 179         }
 180 }
 181
 182 void verifyError (tcu::TestContext& testCtx, const glw::Functions& gl, GLenum expected)
 183 {
 184         deUint32 got = gl.getError();
 185         if (got != expected)
 186         {
 187                 testCtx.getLog() << tcu::TestLog::Message << "// ERROR: expected " << glu::getErrorStr(expected) << "; got " << glu::getErrorStr(got) << tcu::TestLog::EndMessage;
 188                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
 189                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid error");
 190         }
 191 }
 192
 193 void checkCanvasSize (int width, int height, int minWidth, int minHeight)
 194 {
 195         if (width < minWidth || height < minHeight)
 196                 throw tcu::NotSupportedError(std::string("Render context size must be at least ") + de::toString(minWidth) + "x" + de::toString(minWidth));
 197 }
 198
 199 class PositionColorShader : public sglr::ShaderProgram
 200 {
 201 public:
 202         enum
 203         {
 204                 VARYINGLOC_COLOR = 0
 205         };
 206
 207                         PositionColorShader (void);
 208         void    shadeVertices           (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const;
 209         void    shadeFragments          (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const;
 210 };
 211
 212 PositionColorShader::PositionColorShader (void)
 213         : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
 214                                                         << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
 215                                                         << sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
 216                                                         << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
 217                                                         << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
 218                                                         << sglr::pdec::VertexSource(s_shaderSourceVertex)
 219                                                         << sglr::pdec::FragmentSource(s_shaderSourceFragment))
 220 {
 221 }
 222
 223 void PositionColorShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
 224 {
 225         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 226         {
 227                 const int positionAttrLoc = 0;
 228                 const int colorAttrLoc = 1;
 229
 230                 rr::VertexPacket& packet = *packets[packetNdx];
 231
 232                 // Transform to position
 233                 packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx);
 234
 235                 // Pass color to FS
 236                 packet.outputs[VARYINGLOC_COLOR] = rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx);
 237         }
 238 }
 239
 240 void PositionColorShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
 241 {
 242         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 243         {
 244                 rr::FragmentPacket& packet = packets[packetNdx];
 245
 246                 for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
 247                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readTriangleVarying<float>(packet, context, VARYINGLOC_COLOR, fragNdx));
 248         }
 249 }
 250
 251 // PolygonOffsetTestCase
 252
 253 class PolygonOffsetTestCase : public TestCase
 254 {
 255 public:
 256                                         PolygonOffsetTestCase   (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName, int canvasSize);
 257
 258         virtual void    testPolygonOffset               (void) = DE_NULL;
 259         IterateResult   iterate                                 (void);
 260
 261 protected:
 262         const GLenum    m_internalFormat;
 263         const char*             m_internalFormatName;
 264         const int               m_targetSize;
 265 };
 266
 267 PolygonOffsetTestCase::PolygonOffsetTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName, int canvasSize)
 268         : TestCase                              (context, name, description)
 269         , m_internalFormat              (internalFormat)
 270         , m_internalFormatName  (internalFormatName)
 271         , m_targetSize                  (canvasSize)
 272 {
 273 }
 274
 275 PolygonOffsetTestCase::IterateResult PolygonOffsetTestCase::iterate (void)
 276 {
 277         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 278         m_testCtx.getLog() << tcu::TestLog::Message << "Testing PolygonOffset with " << m_internalFormatName << " depth buffer." << tcu::TestLog::EndMessage;
 279
 280         if (m_internalFormat == 0)
 281         {
 282                 // default framebuffer
 283                 const int width         = m_context.getRenderTarget().getWidth();
 284                 const int height        = m_context.getRenderTarget().getHeight();
 285
 286                 checkCanvasSize(width, height, m_targetSize, m_targetSize);
 287
 288                 if (m_context.getRenderTarget().getDepthBits() == 0)
 289                         throw tcu::NotSupportedError("polygon offset tests require depth buffer");
 290
 291                 testPolygonOffset();
 292         }
 293         else
 294         {
 295                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 296
 297                 // framebuffer object
 298                 GLuint  colorRboId      = 0;
 299                 GLuint  depthRboId      = 0;
 300                 GLuint  fboId           = 0;
 301                 bool    fboComplete;
 302
 303                 gl.genRenderbuffers(1, &colorRboId);
 304                 gl.bindRenderbuffer(GL_RENDERBUFFER, colorRboId);
 305                 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, m_targetSize, m_targetSize);
 306                 verifyError(m_testCtx, gl, GL_NO_ERROR);
 307
 308                 gl.genRenderbuffers(1, &depthRboId);
 309                 gl.bindRenderbuffer(GL_RENDERBUFFER, depthRboId);
 310                 gl.renderbufferStorage(GL_RENDERBUFFER, m_internalFormat, m_targetSize, m_targetSize);
 311                 verifyError(m_testCtx, gl, GL_NO_ERROR);
 312
 313                 gl.genFramebuffers(1, &fboId);
 314                 gl.bindFramebuffer(GL_FRAMEBUFFER, fboId);
 315                 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorRboId);
 316                 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRboId);
 317                 verifyError(m_testCtx, gl, GL_NO_ERROR);
 318
 319                 fboComplete = gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
 320
 321                 if (fboComplete)
 322                         testPolygonOffset();
 323
 324                 gl.deleteFramebuffers(1, &fboId);
 325                 gl.deleteRenderbuffers(1, &depthRboId);
 326                 gl.deleteRenderbuffers(1, &colorRboId);
 327
 328                 if (!fboComplete)
 329                         throw tcu::NotSupportedError("could not create fbo for testing.");
 330         }
 331
 332         return STOP;
 333 }
 334
 335 // UsageTestCase
 336
 337 class UsageTestCase : public PolygonOffsetTestCase
 338 {
 339 public:
 340                         UsageTestCase           (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 341
 342         void    testPolygonOffset       (void);
 343 };
 344
 345 UsageTestCase::UsageTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 346         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 347 {
 348 }
 349
 350 void UsageTestCase::testPolygonOffset (void)
 351 {
 352         using tcu::TestLog;
 353
 354         const tcu::Vec4 triangle[] =
 355         {
 356                 tcu::Vec4(-1,  1,  0,  1),
 357                 tcu::Vec4( 1,  1,  0,  1),
 358                 tcu::Vec4( 1, -1,  0,  1),
 359         };
 360
 361         tcu::TestLog&           log                             = m_testCtx.getLog();
 362         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 363         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 364
 365         // render test image
 366         {
 367                 const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
 368                 const glu::ShaderProgram        program         (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 369                 const GLint                                     positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
 370                 const GLint                                     colorLoc        = gl.getAttribLocation(program.getProgram(), "a_color");
 371
 372                 if (!program.isOk())
 373                 {
 374                         log << program;
 375                         TCU_FAIL("Shader compile failed.");
 376                 }
 377
 378                 gl.clearColor                           (0, 0, 0, 1);
 379                 gl.clearDepthf                          (1.0f);
 380                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 381                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
 382                 gl.useProgram                           (program.getProgram());
 383                 gl.enable                                       (GL_DEPTH_TEST);
 384                 gl.depthFunc                            (GL_LEQUAL);    // make test pass if polygon offset doesn't do anything. It has its own test case. This test is only for to detect always-on cases.
 385
 386                 log << TestLog::Message << "DepthFunc = GL_LEQUAL" << TestLog::EndMessage;
 387
 388                 gl.enableVertexAttribArray      (positionLoc);
 389                 gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
 390
 391                 //draw back (offset disabled)
 392
 393                 log << TestLog::Message << "Draw bottom-right. Color = White.\tState: PolygonOffset(0, -2), POLYGON_OFFSET_FILL disabled." << TestLog::EndMessage;
 394
 395                 gl.polygonOffset                        (0, -2);
 396                 gl.disable                                      (GL_POLYGON_OFFSET_FILL);
 397                 gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 398                 gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 399
 400                 //draw front
 401
 402                 log << TestLog::Message << "Draw bottom-right. Color = Red.\tState: PolygonOffset(0, -1), POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
 403
 404                 gl.polygonOffset                        (0, -1);
 405                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
 406                 gl.vertexAttrib4f                       (colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
 407                 gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 408
 409                 gl.disableVertexAttribArray     (positionLoc);
 410                 gl.useProgram                           (0);
 411                 gl.finish                                       ();
 412
 413                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
 414         }
 415
 416         // render reference image
 417         {
 418                 rr::Renderer            referenceRenderer;
 419                 rr::VertexAttrib        attribs[2];
 420                 rr::RenderState         state((rr::ViewportState)(rr::WindowRectangle(0, 0, m_targetSize, m_targetSize)));
 421
 422                 PositionColorShader program;
 423
 424                 attribs[0].type                         = rr::VERTEXATTRIBTYPE_FLOAT;
 425                 attribs[0].size                         = 4;
 426                 attribs[0].stride                       = 0;
 427                 attribs[0].instanceDivisor      = 0;
 428                 attribs[0].pointer                      = triangle;
 429
 430                 attribs[1].type                         = rr::VERTEXATTRIBTYPE_DONT_CARE;
 431                 attribs[1].generic                      = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
 432
 433                 tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 434
 435                 log << TestLog::Message << "Expecting: Bottom-right = Red." << TestLog::EndMessage;
 436
 437                 referenceRenderer.draw(
 438                         rr::DrawCommand(
 439                                 state,
 440                                 rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
 441                                 rr::Program(program.getVertexShader(), program.getFragmentShader()),
 442                                 2,
 443                                 attribs,
 444                                 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
 445         }
 446
 447         // compare
 448         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
 449 }
 450
 451 // UsageDisplacementTestCase
 452
 453 class UsageDisplacementTestCase : public PolygonOffsetTestCase
 454 {
 455 public:
 456                                 UsageDisplacementTestCase       (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 457
 458 private:
 459         tcu::Vec4       genRandomVec4                           (de::Random& rnd) const;
 460         void            testPolygonOffset                       (void);
 461 };
 462
 463 UsageDisplacementTestCase::UsageDisplacementTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 464         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 465 {
 466 }
 467
 468 tcu::Vec4 UsageDisplacementTestCase::genRandomVec4 (de::Random& rnd) const
 469 {
 470         // generater triangle endpoint with following properties
 471         //      1) it will not be clipped
 472         //      2) it is not near either far or near plane to prevent possible problems related to depth clamping
 473         // => w >= 1.0 and z in (-0.9, 0.9) range
 474         tcu::Vec4 retVal;
 475
 476         retVal.x() = rnd.getFloat(-1, 1);
 477         retVal.y() = rnd.getFloat(-1, 1);
 478         retVal.z() = rnd.getFloat(-0.9f, 0.9f);
 479         retVal.w() = 1.0f + rnd.getFloat();
 480
 481         return retVal;
 482 }
 483
 484 void UsageDisplacementTestCase::testPolygonOffset (void)
 485 {
 486         using tcu::TestLog;
 487
 488         de::Random                      rnd                             (0xdec0de);
 489         tcu::TestLog&           log                             = m_testCtx.getLog();
 490         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 491         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 492
 493         // render test image
 494         {
 495                 const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
 496                 const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 497                 const GLint                                     positionLoc             = gl.getAttribLocation(program.getProgram(), "a_position");
 498                 const GLint                                     colorLoc                = gl.getAttribLocation(program.getProgram(), "a_color");
 499                 const int                                       numIterations   = 40;
 500
 501                 if (!program.isOk())
 502                 {
 503                         log << program;
 504                         TCU_FAIL("Shader compile failed.");
 505                 }
 506
 507                 gl.clearColor                           (0, 0, 0, 1);
 508                 gl.clearDepthf                          (1.0f);
 509                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 510                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
 511                 gl.useProgram                           (program.getProgram());
 512                 gl.enable                                       (GL_DEPTH_TEST);
 513                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
 514                 gl.enableVertexAttribArray      (positionLoc);
 515                 gl.vertexAttrib4f                       (colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
 516
 517                 log << TestLog::Message << "Framebuffer cleared, clear color = Black." << TestLog::EndMessage;
 518                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
 519
 520                 // draw colorless (mask = 0,0,0) triangle at random* location, set offset and render green triangle with depthfunc = equal
 521                 // *) w >= 1.0 and z in (-1, 1) range
 522                 for (int iterationNdx = 0; iterationNdx < numIterations; ++iterationNdx)
 523                 {
 524                         const bool              offsetDirection = rnd.getBool();
 525                         const float             offset = offsetDirection ? -1.0f : 1.0f;
 526                         tcu::Vec4               triangle[3];
 527
 528                         for (int vertexNdx = 0; vertexNdx < DE_LENGTH_OF_ARRAY(triangle); ++vertexNdx)
 529                                 triangle[vertexNdx] = genRandomVec4(rnd);
 530
 531                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
 532
 533                         log << TestLog::Message << "Setup triangle with random coordinates:" << TestLog::EndMessage;
 534                         for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangle); ++ndx)
 535                                 log << TestLog::Message
 536                                                 << "\tx=" << triangle[ndx].x()
 537                                                 << "\ty=" << triangle[ndx].y()
 538                                                 << "\tz=" << triangle[ndx].z()
 539                                                 << "\tw=" << triangle[ndx].w()
 540                                                 << TestLog::EndMessage;
 541
 542                         log << TestLog::Message << "Draw colorless triangle.\tState: DepthFunc = GL_ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
 543
 544                         gl.depthFunc                            (GL_ALWAYS);
 545                         gl.polygonOffset                        (0, 0);
 546                         gl.colorMask                            (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 547                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 548
 549                         // all fragments should have different Z => DepthFunc == GL_EQUAL fails with every fragment
 550
 551                         log << TestLog::Message << "Draw green triangle.\tState: DepthFunc = GL_EQUAL, PolygonOffset(0, " << offset << ")." << TestLog::EndMessage;
 552
 553                         gl.depthFunc                            (GL_EQUAL);
 554                         gl.polygonOffset                        (0, offset);
 555                         gl.colorMask                            (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 556                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 557
 558                         log << TestLog::Message << TestLog::EndMessage; // empty line for clarity
 559                 }
 560
 561                 gl.disableVertexAttribArray     (positionLoc);
 562                 gl.useProgram                           (0);
 563                 gl.finish                                       ();
 564
 565                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
 566         }
 567
 568         // render reference image
 569         log << TestLog::Message << "Expecting black framebuffer." << TestLog::EndMessage;
 570         tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 571
 572         // compare
 573         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
 574 }
 575
 576 // UsagePositiveNegativeTestCase
 577
 578 class UsagePositiveNegativeTestCase : public PolygonOffsetTestCase
 579 {
 580 public:
 581                         UsagePositiveNegativeTestCase   (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 582
 583         void    testPolygonOffset                               (void);
 584 };
 585
 586 UsagePositiveNegativeTestCase::UsagePositiveNegativeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 587         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 588 {
 589 }
 590
 591 void UsagePositiveNegativeTestCase::testPolygonOffset (void)
 592 {
 593         using tcu::TestLog;
 594
 595         const tcu::Vec4 triangleBottomRight[] =
 596         {
 597                 tcu::Vec4(-1,  1,  0,  1),
 598                 tcu::Vec4( 1,  1,  0,  1),
 599                 tcu::Vec4( 1, -1,  0,  1),
 600         };
 601         const tcu::Vec4 triangleTopLeft[] =
 602         {
 603                 tcu::Vec4(-1, -1,  0,  1),
 604                 tcu::Vec4(-1,  1,  0,  1),
 605                 tcu::Vec4( 1, -1,  0,  1),
 606         };
 607
 608         tcu::TestLog&           log                             = m_testCtx.getLog();
 609         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 610         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 611
 612         // render test image
 613         {
 614                 const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
 615                 const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 616                 const GLint                                     positionLoc             = gl.getAttribLocation(program.getProgram(), "a_position");
 617                 const GLint                                     colorLoc                = gl.getAttribLocation(program.getProgram(), "a_color");
 618
 619                 if (!program.isOk())
 620                 {
 621                         log << program;
 622                         TCU_FAIL("Shader compile failed.");
 623                 }
 624
 625                 gl.clearColor                           (0, 0, 0, 1);
 626                 gl.clearDepthf                          (1.0f);
 627                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 628                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
 629                 gl.depthFunc                            (GL_LESS);
 630                 gl.useProgram                           (program.getProgram());
 631                 gl.enable                                       (GL_DEPTH_TEST);
 632                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
 633                 gl.enableVertexAttribArray      (positionLoc);
 634
 635                 log << TestLog::Message << "DepthFunc = GL_LESS." << TestLog::EndMessage;
 636                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
 637
 638                 //draw top left (negative offset test)
 639                 {
 640                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
 641
 642                         log << TestLog::Message << "Draw top-left. Color = White.\tState: PolygonOffset(0, 0)." << TestLog::EndMessage;
 643
 644                         gl.polygonOffset                        (0, 0);
 645                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 646                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 647
 648                         log << TestLog::Message << "Draw top-left. Color = Green.\tState: PolygonOffset(0, -1)." << TestLog::EndMessage;
 649
 650                         gl.polygonOffset                        (0, -1);
 651                         gl.vertexAttrib4f                       (colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
 652                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 653                 }
 654
 655                 //draw bottom right (positive offset test)
 656                 {
 657                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
 658
 659                         log << TestLog::Message << "Draw bottom-right. Color = White.\tState: PolygonOffset(0, 1)." << TestLog::EndMessage;
 660
 661                         gl.polygonOffset                        (0, 1);
 662                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 663                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 664
 665                         log << TestLog::Message << "Draw bottom-right. Color = Yellow.\tState: PolygonOffset(0, 0)." << TestLog::EndMessage;
 666
 667                         gl.polygonOffset                        (0, 0);
 668                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 0.0f, 1.0f);
 669                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 670                 }
 671
 672                 gl.disableVertexAttribArray     (positionLoc);
 673                 gl.useProgram                           (0);
 674                 gl.finish                                       ();
 675
 676                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
 677         }
 678
 679         // render reference image
 680         {
 681                 rr::Renderer            referenceRenderer;
 682                 rr::VertexAttrib        attribs[2];
 683                 rr::RenderState         state((rr::ViewportState)(rr::WindowRectangle(0, 0, m_targetSize, m_targetSize)));
 684
 685                 PositionColorShader program;
 686
 687                 attribs[0].type                         = rr::VERTEXATTRIBTYPE_FLOAT;
 688                 attribs[0].size                         = 4;
 689                 attribs[0].stride                       = 0;
 690                 attribs[0].instanceDivisor      = 0;
 691                 attribs[0].pointer                      = triangleTopLeft;
 692
 693                 attribs[1].type                         = rr::VERTEXATTRIBTYPE_DONT_CARE;
 694                 attribs[1].generic                      = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
 695
 696                 tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 697
 698                 log << TestLog::Message << "Expecting: Top-left = Green, Bottom-right = Yellow." << TestLog::EndMessage;
 699
 700                 referenceRenderer.draw(
 701                         rr::DrawCommand(
 702                                 state,
 703                                 rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
 704                                 rr::Program(program.getVertexShader(), program.getFragmentShader()),
 705                                 2,
 706                                 attribs,
 707                                 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
 708
 709                 attribs[0].pointer = triangleBottomRight;
 710                 attribs[1].generic = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
 711
 712                 referenceRenderer.draw(
 713                         rr::DrawCommand(
 714                                 state,
 715                                 rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
 716                                 rr::Program(program.getVertexShader(), program.getFragmentShader()),
 717                                 2,
 718                                 attribs,
 719                                 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
 720         }
 721
 722         // compare
 723         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
 724 }
 725
 726 // ResultClampingTestCase
 727
 728 class ResultClampingTestCase : public PolygonOffsetTestCase
 729 {
 730 public:
 731                         ResultClampingTestCase  (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 732
 733         void    testPolygonOffset               (void);
 734 };
 735
 736 ResultClampingTestCase::ResultClampingTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 737         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 738 {
 739 }
 740
 741 void ResultClampingTestCase::testPolygonOffset (void)
 742 {
 743         using tcu::TestLog;
 744
 745         const tcu::Vec4 triangleBottomRight[] =
 746         {
 747                 tcu::Vec4(-1,  1,  1,  1),
 748                 tcu::Vec4( 1,  1,  1,  1),
 749                 tcu::Vec4( 1, -1,  1,  1),
 750         };
 751         const tcu::Vec4 triangleTopLeft[] =
 752         {
 753                 tcu::Vec4(-1, -1, -1,  1),
 754                 tcu::Vec4(-1,  1, -1,  1),
 755                 tcu::Vec4( 1, -1, -1,  1),
 756         };
 757
 758         tcu::TestLog&           log                             = m_testCtx.getLog();
 759         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 760         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 761
 762         // render test image
 763         {
 764                 const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
 765                 const glu::ShaderProgram        program         (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 766                 const GLint                                     positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
 767                 const GLint                                     colorLoc        = gl.getAttribLocation(program.getProgram(), "a_color");
 768
 769                 if (!program.isOk())
 770                 {
 771                         log << program;
 772                         TCU_FAIL("Shader compile failed.");
 773                 }
 774
 775                 gl.clearColor                           (0, 0, 0, 1);
 776                 gl.clearDepthf                          (1.0f);
 777                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 778                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
 779                 gl.useProgram                           (program.getProgram());
 780                 gl.enable                                       (GL_DEPTH_TEST);
 781                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
 782                 gl.enableVertexAttribArray      (positionLoc);
 783
 784                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
 785
 786                 //draw bottom right (far)
 787                 {
 788                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
 789
 790                         log << TestLog::Message << "Draw bottom-right. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 8), Polygon Z = 1.0. (Result depth should clamp to 1.0)." << TestLog::EndMessage;
 791
 792                         gl.depthFunc                            (GL_ALWAYS);
 793                         gl.polygonOffset                        (0, 8);
 794                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 795                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 796
 797                         log << TestLog::Message << "Draw bottom-right. Color = Red.\tState: DepthFunc = GREATER, PolygonOffset(0, 9), Polygon Z = 1.0. (Result depth should clamp to 1.0 too)" << TestLog::EndMessage;
 798
 799                         gl.depthFunc                            (GL_GREATER);
 800                         gl.polygonOffset                        (0, 9);
 801                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
 802                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 803                 }
 804
 805                 //draw top left (near)
 806                 {
 807                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
 808
 809                         log << TestLog::Message << "Draw top-left. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, -8), Polygon Z = -1.0. (Result depth should clamp to -1.0)" << TestLog::EndMessage;
 810
 811                         gl.depthFunc                            (GL_ALWAYS);
 812                         gl.polygonOffset                        (0, -8);
 813                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 814                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 815
 816                         log << TestLog::Message << "Draw top-left. Color = Yellow.\tState: DepthFunc = LESS, PolygonOffset(0, -9), Polygon Z = -1.0. (Result depth should clamp to -1.0 too)." << TestLog::EndMessage;
 817
 818                         gl.depthFunc                            (GL_LESS);
 819                         gl.polygonOffset                        (0, -9);
 820                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 0.0f, 1.0f);
 821                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 822                 }
 823
 824                 gl.disableVertexAttribArray     (positionLoc);
 825                 gl.useProgram                           (0);
 826                 gl.finish                                       ();
 827
 828                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
 829         }
 830
 831         // render reference image
 832         log << TestLog::Message << "Expecting: Top-left = White, Bottom-right = White." << TestLog::EndMessage;
 833         tcu::clear(referenceImage.getAccess(), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
 834
 835         // compare
 836         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
 837 }
 838
 839 // UsageSlopeTestCase
 840
 841 class UsageSlopeTestCase  : public PolygonOffsetTestCase
 842 {
 843 public:
 844                         UsageSlopeTestCase      (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 845
 846         void    testPolygonOffset       (void);
 847 };
 848
 849 UsageSlopeTestCase::UsageSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 850         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 851 {
 852 }
 853
 854 void UsageSlopeTestCase::testPolygonOffset (void)
 855 {
 856         using tcu::TestLog;
 857
 858         const tcu::Vec4 triangleBottomRight[] =
 859         {
 860                 tcu::Vec4(-1,  1,  0.0f,  1),
 861                 tcu::Vec4( 1,  1,  0.9f,  1),
 862                 tcu::Vec4( 1, -1,  0.9f,  1),
 863         };
 864         const tcu::Vec4 triangleTopLeft[] =
 865         {
 866                 tcu::Vec4(-1, -1,  -0.9f,  1),
 867                 tcu::Vec4(-1,  1,   0.9f,  1),
 868                 tcu::Vec4( 1, -1,   0.0f,  1),
 869         };
 870
 871         tcu::TestLog&           log                             = m_testCtx.getLog();
 872         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 873         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 874
 875         // render test image
 876         {
 877                 const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
 878                 const glu::ShaderProgram        program         (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 879                 const GLint                                     positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
 880                 const GLint                                     colorLoc        = gl.getAttribLocation(program.getProgram(), "a_color");
 881
 882                 if (!program.isOk())
 883                 {
 884                         log << program;
 885                         TCU_FAIL("Shader compile failed.");
 886                 }
 887
 888                 gl.clearColor                           (0, 0, 0, 1);
 889                 gl.clearDepthf                          (1.0f);
 890                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 891                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
 892                 gl.useProgram                           (program.getProgram());
 893                 gl.enable                                       (GL_DEPTH_TEST);
 894                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
 895                 gl.enableVertexAttribArray      (positionLoc);
 896
 897                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
 898
 899                 //draw top left (negative offset test)
 900                 {
 901                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
 902
 903                         log << TestLog::Message << "Draw top-left. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
 904
 905                         gl.depthFunc                            (GL_ALWAYS);
 906                         gl.polygonOffset                        (0, 0);
 907                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 908                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 909
 910                         log << TestLog::Message << "Draw top-left. Color = Green.\tState: DepthFunc = LESS, PolygonOffset(-1, 0)." << TestLog::EndMessage;
 911
 912                         gl.depthFunc                            (GL_LESS);
 913                         gl.polygonOffset                        (-1, 0);
 914                         gl.vertexAttrib4f                       (colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
 915                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 916                 }
 917
 918                 //draw bottom right (positive offset test)
 919                 {
 920                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
 921
 922                         log << TestLog::Message << "Draw bottom-right. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
 923
 924                         gl.depthFunc                            (GL_ALWAYS);
 925                         gl.polygonOffset                        (0, 0);
 926                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
 927                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 928
 929                         log << TestLog::Message << "Draw bottom-right. Color = Green.\tState: DepthFunc = GREATER, PolygonOffset(1, 0)." << TestLog::EndMessage;
 930
 931                         gl.depthFunc                            (GL_GREATER);
 932                         gl.polygonOffset                        (1, 0);
 933                         gl.vertexAttrib4f                       (colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
 934                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
 935                 }
 936
 937                 gl.disableVertexAttribArray     (positionLoc);
 938                 gl.useProgram                           (0);
 939                 gl.finish                                       ();
 940
 941                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
 942         }
 943
 944         // render reference image
 945         log << TestLog::Message << "Expecting: Top-left = Green, Bottom-right = Green." << TestLog::EndMessage;
 946         tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));
 947
 948         // compare
 949         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
 950 }
 951
 952 // ZeroSlopeTestCase
 953
 954 class ZeroSlopeTestCase : public PolygonOffsetTestCase
 955 {
 956 public:
 957                         ZeroSlopeTestCase       (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
 958
 959         void    testPolygonOffset       (void);
 960 };
 961
 962 ZeroSlopeTestCase::ZeroSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
 963         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
 964 {
 965 }
 966
 967 void ZeroSlopeTestCase::testPolygonOffset (void)
 968 {
 969         using tcu::TestLog;
 970
 971         const tcu::Vec4 triangle[] =
 972         {
 973                 tcu::Vec4(-0.4f,  0.4f, 0.0f, 1.0f),
 974                 tcu::Vec4(-0.8f, -0.5f, 0.0f, 1.0f),
 975                 tcu::Vec4( 0.7f,  0.2f, 0.0f, 1.0f),
 976         };
 977
 978         tcu::TestLog&           log                             = m_testCtx.getLog();
 979         tcu::Surface            testImage               (m_targetSize, m_targetSize);
 980         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
 981
 982         // log the triangle
 983         log << TestLog::Message << "Setup triangle with coordinates:" << TestLog::EndMessage;
 984         for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangle); ++ndx)
 985                 log << TestLog::Message
 986                                 << "\tx=" << triangle[ndx].x()
 987                                 << "\ty=" << triangle[ndx].y()
 988                                 << "\tz=" << triangle[ndx].z()
 989                                 << "\tw=" << triangle[ndx].w()
 990                                 << TestLog::EndMessage;
 991
 992         // render test image
 993         {
 994                 const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
 995                 const glu::ShaderProgram        program         (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
 996                 const GLint                                     positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
 997                 const GLint                                     colorLoc        = gl.getAttribLocation(program.getProgram(), "a_color");
 998
 999                 if (!program.isOk())
1000                 {
1001                         log << program;
1002                         TCU_FAIL("Shader compile failed.");
1003                 }
1004
1005                 gl.clearColor                           (0, 0, 0, 1);
1006                 gl.clearDepthf                          (1.0f);
1007                 gl.clear                                        (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1008                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
1009                 gl.useProgram                           (program.getProgram());
1010                 gl.enable                                       (GL_DEPTH_TEST);
1011                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
1012                 gl.enableVertexAttribArray      (positionLoc);
1013
1014                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
1015
1016                 {
1017                         gl.vertexAttribPointer          (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
1018
1019                         log << TestLog::Message << "Draw triangle. Color = Red.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
1020
1021                         gl.depthFunc                            (GL_ALWAYS);
1022                         gl.polygonOffset                        (0, 0);
1023                         gl.vertexAttrib4f                       (colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
1024                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
1025
1026                         log << TestLog::Message << "Draw triangle. Color = Black.\tState: DepthFunc = EQUAL, PolygonOffset(4, 0)." << TestLog::EndMessage;
1027
1028                         gl.depthFunc                            (GL_EQUAL);
1029                         gl.polygonOffset                        (4, 0); // triangle slope == 0
1030                         gl.vertexAttrib4f                       (colorLoc, 0.0f, 0.0f, 0.0f, 1.0f);
1031                         gl.drawArrays                           (GL_TRIANGLES, 0, 3);
1032                 }
1033
1034                 gl.disableVertexAttribArray     (positionLoc);
1035                 gl.useProgram                           (0);
1036                 gl.finish                                       ();
1037
1038                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
1039         }
1040
1041         // render reference image
1042         log << TestLog::Message << "Expecting black triangle." << TestLog::EndMessage;
1043         tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
1044
1045         // compare
1046         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
1047 }
1048
1049 // OneSlopeTestCase
1050
1051 class OneSlopeTestCase : public PolygonOffsetTestCase
1052 {
1053 public:
1054                         OneSlopeTestCase        (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
1055
1056         void    testPolygonOffset       (void);
1057 };
1058
1059 OneSlopeTestCase::OneSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
1060         : PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
1061 {
1062 }
1063
1064 void OneSlopeTestCase::testPolygonOffset (void)
1065 {
1066         using tcu::TestLog;
1067
1068         /*
1069                 * setup vertices subject to following properties
1070                 *   dz_w / dx_w == 1
1071                 *   dz_w / dy_w == 0
1072                 * or
1073                 *   dz_w / dx_w == 0
1074                 *   dz_w / dy_w == 1
1075                 * ==> m == 1
1076                 */
1077         const float cornerDepth = float(m_targetSize);
1078         const tcu::Vec4 triangles[2][3] =
1079         {
1080                 {
1081                         tcu::Vec4(-1, -1, -cornerDepth, 1),
1082                         tcu::Vec4(-1,  1, -cornerDepth, 1),
1083                         tcu::Vec4( 1, -1,  cornerDepth, 1),
1084                 },
1085                 {
1086                         tcu::Vec4(-1,  1,  cornerDepth, 1),
1087                         tcu::Vec4( 1,  1,  cornerDepth, 1),
1088                         tcu::Vec4( 1, -1, -cornerDepth, 1),
1089                 },
1090         };
1091
1092         tcu::TestLog&           log                             = m_testCtx.getLog();
1093         tcu::Surface            testImage               (m_targetSize, m_targetSize);
1094         tcu::Surface            referenceImage  (m_targetSize, m_targetSize);
1095
1096         // log triangle info
1097         log << TestLog::Message << "Setup triangle0 coordinates: (slope in window coordinates = 1.0)" << TestLog::EndMessage;
1098         for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangles[0]); ++ndx)
1099                 log << TestLog::Message
1100                                 << "\tx=" << triangles[0][ndx].x()
1101                                 << "\ty=" << triangles[0][ndx].y()
1102                                 << "\tz=" << triangles[0][ndx].z()
1103                                 << "\tw=" << triangles[0][ndx].w()
1104                                 << TestLog::EndMessage;
1105         log << TestLog::Message << "Setup triangle1 coordinates: (slope in window coordinates = 1.0)" << TestLog::EndMessage;
1106         for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangles[1]); ++ndx)
1107                 log << TestLog::Message
1108                                 << "\tx=" << triangles[1][ndx].x()
1109                                 << "\ty=" << triangles[1][ndx].y()
1110                                 << "\tz=" << triangles[1][ndx].z()
1111                                 << "\tw=" << triangles[1][ndx].w()
1112                                 << TestLog::EndMessage;
1113
1114         // render test image
1115         {
1116                 const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
1117                 const glu::ShaderProgram        program         (m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
1118                 const GLint                                     positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
1119                 const GLint                                     colorLoc        = gl.getAttribLocation(program.getProgram(), "a_color");
1120
1121                 if (!program.isOk())
1122                 {
1123                         log << program;
1124                         TCU_FAIL("Shader compile failed.");
1125                 }
1126
1127                 gl.clearColor                           (0, 0, 0, 1);
1128                 gl.clear                                        (GL_COLOR_BUFFER_BIT);
1129                 gl.viewport                                     (0, 0, m_targetSize, m_targetSize);
1130                 gl.useProgram                           (program.getProgram());
1131                 gl.enable                                       (GL_DEPTH_TEST);
1132                 gl.enable                                       (GL_POLYGON_OFFSET_FILL);
1133                 gl.enableVertexAttribArray      (positionLoc);
1134
1135                 log << TestLog::Message << "Framebuffer cleared, clear color = Black." << TestLog::EndMessage;
1136                 log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
1137
1138                 // top left (positive offset)
1139                 {
1140                         log << TestLog::Message << "Clear depth to 1.0." << TestLog::EndMessage;
1141
1142                         gl.clearDepthf                  (1.0f); // far
1143                         gl.clear                                (GL_DEPTH_BUFFER_BIT);
1144
1145                         gl.vertexAttribPointer  (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangles[0]);
1146
1147                         log << TestLog::Message << "Draw triangle0. Color = Red.\tState: DepthFunc = NOTEQUAL, PolygonOffset(10, 0). (Result depth should clamp to 1.0)." << TestLog::EndMessage;
1148
1149                         gl.polygonOffset                (10, 0);                // clamps any depth on the triangle to 1
1150                         gl.depthFunc                    (GL_NOTEQUAL);
1151                         gl.vertexAttrib4f               (colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
1152                         gl.drawArrays                   (GL_TRIANGLES, 0, 3);
1153                 }
1154                 // bottom right (negative offset)
1155                 {
1156                         log << TestLog::Message << "Clear depth to 0.0." << TestLog::EndMessage;
1157
1158                         gl.clearDepthf                  (0.0f); // far
1159                         gl.clear                                (GL_DEPTH_BUFFER_BIT);
1160
1161                         gl.vertexAttribPointer  (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangles[1]);
1162
1163                         log << TestLog::Message << "Draw triangle1. Color = Green.\tState: DepthFunc = NOTEQUAL, PolygonOffset(-10, 0). (Result depth should clamp to 0.0)." << TestLog::EndMessage;
1164
1165                         gl.polygonOffset                (-10, 0); // clamps depth to 0
1166                         gl.depthFunc                    (GL_NOTEQUAL);
1167                         gl.vertexAttrib4f               (colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
1168                         gl.drawArrays                   (GL_TRIANGLES, 0, 3);
1169                 }
1170
1171                 gl.disableVertexAttribArray     (positionLoc);
1172                 gl.useProgram                           (0);
1173                 gl.finish                                       ();
1174
1175                 glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
1176         }
1177
1178         // render reference image
1179         log << TestLog::Message << "Expecting black framebuffer." << TestLog::EndMessage;
1180         tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
1181
1182         // compare
1183         verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
1184 }
1185
1186 } // anonymous
1187
1188 PolygonOffsetTests::PolygonOffsetTests (Context& context)
1189         : TestCaseGroup(context, "polygon_offset", "Polygon offset tests")
1190 {
1191 }
1192
1193 PolygonOffsetTests::~PolygonOffsetTests (void)
1194 {
1195 }
1196
1197 void PolygonOffsetTests::init (void)
1198 {
1199         const struct DepthBufferFormat
1200         {
1201                 enum BufferType
1202                 {
1203                         TYPE_FIXED_POINT,
1204                         TYPE_FLOATING_POINT,
1205                         TYPE_UNKNOWN
1206                 };
1207
1208                 GLenum          internalFormat;
1209                 int                     bits;
1210                 BufferType      floatingPoint;
1211                 const char* name;
1212         } depthFormats[]=
1213         {
1214                 { 0,                                            0,              DepthBufferFormat::TYPE_UNKNOWN,                "default" },
1215                 { GL_DEPTH_COMPONENT16,         16,             DepthBufferFormat::TYPE_FIXED_POINT,    "fixed16" },
1216         };
1217
1218         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFormats); ++ndx)
1219         {
1220                 const DepthBufferFormat& format = depthFormats[ndx];
1221
1222                 // enable works?
1223                 addChild(new UsageTestCase(m_context, (std::string(format.name) + "_enable").c_str(), "test enable GL_POLYGON_OFFSET_FILL", format.internalFormat, format.name));
1224
1225                 // Really moves the polygons ?
1226                 addChild(new UsageDisplacementTestCase(m_context, (std::string(format.name) + "_displacement_with_units").c_str(), "test polygon offset", format.internalFormat, format.name));
1227
1228                 // Really moves the polygons to right direction ?
1229                 addChild(new UsagePositiveNegativeTestCase(m_context, (std::string(format.name) + "_render_with_units").c_str(), "test polygon offset", format.internalFormat, format.name));
1230
1231                 // Is total result clamped to [0,1] like promised?
1232                 addChild(new ResultClampingTestCase(m_context, (std::string(format.name) + "_result_depth_clamp").c_str(), "test polygon offset clamping", format.internalFormat, format.name));
1233
1234                 // Slope really moves the polygon?
1235                 addChild(new UsageSlopeTestCase(m_context, (std::string(format.name) + "_render_with_factor").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1236
1237                 // Factor with zero slope
1238                 addChild(new ZeroSlopeTestCase(m_context, (std::string(format.name) + "_factor_0_slope").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1239
1240                 // Factor with 1.0 slope
1241                 addChild(new OneSlopeTestCase(m_context, (std::string(format.name) + "_factor_1_slope").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1242         }
1243 }
1244
1245 } // Functional
1246 } // gles2
1247 } // deqp