modules/gles3/functional/es3fShaderDerivateTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader derivate function tests.
  22  *
  23  * \todo [2013-06-25 pyry] Missing features:
  24  *  - lines and points
  25  *  - projected coordinates
  26  *  - continous non-trivial functions (sin, exp)
  27  *  - non-continous functions (step)
  28  *//*--------------------------------------------------------------------*/
  29
  30 #include "es3fShaderDerivateTests.hpp"
  31 #include "gluShaderProgram.hpp"
  32 #include "gluRenderContext.hpp"
  33 #include "gluDrawUtil.hpp"
  34 #include "gluPixelTransfer.hpp"
  35 #include "gluShaderUtil.hpp"
  36 #include "gluStrUtil.hpp"
  37 #include "gluTextureUtil.hpp"
  38 #include "gluTexture.hpp"
  39 #include "tcuStringTemplate.hpp"
  40 #include "tcuRenderTarget.hpp"
  41 #include "tcuSurface.hpp"
  42 #include "tcuTestLog.hpp"
  43 #include "tcuVectorUtil.hpp"
  44 #include "tcuTextureUtil.hpp"
  45 #include "tcuRGBA.hpp"
  46 #include "tcuFloat.hpp"
  47 #include "tcuInterval.hpp"
  48 #include "deRandom.hpp"
  49 #include "deUniquePtr.hpp"
  50 #include "deString.h"
  51 #include "glwEnums.hpp"
  52 #include "glwFunctions.hpp"
  53 #include "glsShaderRenderCase.hpp" // gls::setupDefaultUniforms()
  54
  55 #include <sstream>
  56
  57 namespace deqp
  58 {
  59 namespace gles3
  60 {
  61 namespace Functional
  62 {
  63
  64 using std::vector;
  65 using std::string;
  66 using std::map;
  67 using tcu::TestLog;
  68 using std::ostringstream;
  69
  70 enum
  71 {
  72         VIEWPORT_WIDTH          = 167,
  73         VIEWPORT_HEIGHT         = 103,
  74         FBO_WIDTH                       = 99,
  75         FBO_HEIGHT                      = 133,
  76         MAX_FAILED_MESSAGES     = 10
  77 };
  78
  79 enum DerivateFunc
  80 {
  81         DERIVATE_DFDX   = 0,
  82         DERIVATE_DFDY,
  83         DERIVATE_FWIDTH,
  84
  85         DERIVATE_LAST
  86 };
  87
  88 enum SurfaceType
  89 {
  90         SURFACETYPE_DEFAULT_FRAMEBUFFER = 0,
  91         SURFACETYPE_UNORM_FBO,
  92         SURFACETYPE_FLOAT_FBO,  // \note Uses RGBA32UI fbo actually, since FP rendertargets are not in core spec.
  93
  94         SURFACETYPE_LAST
  95 };
  96
  97 // Utilities
  98
  99 namespace
 100 {
 101
 102 class AutoFbo
 103 {
 104 public:
 105         AutoFbo (const glw::Functions& gl)
 106                 : m_gl  (gl)
 107                 , m_fbo (0)
 108         {
 109         }
 110
 111         ~AutoFbo (void)
 112         {
 113                 if (m_fbo)
 114                         m_gl.deleteFramebuffers(1, &m_fbo);
 115         }
 116
 117         void gen (void)
 118         {
 119                 DE_ASSERT(!m_fbo);
 120                 m_gl.genFramebuffers(1, &m_fbo);
 121         }
 122
 123         deUint32 operator* (void) const { return m_fbo; }
 124
 125 private:
 126         const glw::Functions&   m_gl;
 127         deUint32                                m_fbo;
 128 };
 129
 130 class AutoRbo
 131 {
 132 public:
 133         AutoRbo (const glw::Functions& gl)
 134                 : m_gl  (gl)
 135                 , m_rbo (0)
 136         {
 137         }
 138
 139         ~AutoRbo (void)
 140         {
 141                 if (m_rbo)
 142                         m_gl.deleteRenderbuffers(1, &m_rbo);
 143         }
 144
 145         void gen (void)
 146         {
 147                 DE_ASSERT(!m_rbo);
 148                 m_gl.genRenderbuffers(1, &m_rbo);
 149         }
 150
 151         deUint32 operator* (void) const { return m_rbo; }
 152
 153 private:
 154         const glw::Functions&   m_gl;
 155         deUint32                                m_rbo;
 156 };
 157
 158 } // anonymous
 159
 160 static const char* getDerivateFuncName (DerivateFunc func)
 161 {
 162         switch (func)
 163         {
 164                 case DERIVATE_DFDX:             return "dFdx";
 165                 case DERIVATE_DFDY:             return "dFdy";
 166                 case DERIVATE_FWIDTH:   return "fwidth";
 167                 default:
 168                         DE_ASSERT(false);
 169                         return DE_NULL;
 170         }
 171 }
 172
 173 static const char* getDerivateFuncCaseName (DerivateFunc func)
 174 {
 175         switch (func)
 176         {
 177                 case DERIVATE_DFDX:             return "dfdx";
 178                 case DERIVATE_DFDY:             return "dfdy";
 179                 case DERIVATE_FWIDTH:   return "fwidth";
 180                 default:
 181                         DE_ASSERT(false);
 182                         return DE_NULL;
 183         }
 184 }
 185
 186 static inline tcu::BVec4 getDerivateMask (glu::DataType type)
 187 {
 188         switch (type)
 189         {
 190                 case glu::TYPE_FLOAT:           return tcu::BVec4(true, false, false, false);
 191                 case glu::TYPE_FLOAT_VEC2:      return tcu::BVec4(true, true, false, false);
 192                 case glu::TYPE_FLOAT_VEC3:      return tcu::BVec4(true, true, true, false);
 193                 case glu::TYPE_FLOAT_VEC4:      return tcu::BVec4(true, true, true, true);
 194                 default:
 195                         DE_ASSERT(false);
 196                         return tcu::BVec4(true);
 197         }
 198 }
 199
 200 static inline tcu::Vec4 readDerivate (const tcu::ConstPixelBufferAccess& surface, const tcu::Vec4& derivScale, const tcu::Vec4& derivBias, int x, int y)
 201 {
 202         return (surface.getPixel(x, y) - derivBias) / derivScale;
 203 }
 204
 205 static inline tcu::UVec4 getCompExpBits (const tcu::Vec4& v)
 206 {
 207         return tcu::UVec4(tcu::Float32(v[0]).exponentBits(),
 208                                           tcu::Float32(v[1]).exponentBits(),
 209                                           tcu::Float32(v[2]).exponentBits(),
 210                                           tcu::Float32(v[3]).exponentBits());
 211 }
 212
 213 float computeFloatingPointError (const float value, const int numAccurateBits)
 214 {
 215         const int               numGarbageBits  = 23-numAccurateBits;
 216         const deUint32  mask                    = (1u<<numGarbageBits)-1u;
 217         const int               exp                             = tcu::Float32(value).exponent();
 218
 219         return tcu::Float32::construct(+1, exp, (1u<<23) | mask).asFloat() - tcu::Float32::construct(+1, exp, 1u<<23).asFloat();
 220 }
 221
 222 static int getNumMantissaBits (const glu::Precision precision)
 223 {
 224         switch (precision)
 225         {
 226                 case glu::PRECISION_HIGHP:              return 23;
 227                 case glu::PRECISION_MEDIUMP:    return 10;
 228                 case glu::PRECISION_LOWP:               return 6;
 229                 default:
 230                         DE_ASSERT(false);
 231                         return 0;
 232         }
 233 }
 234
 235 static int getMinExponent (const glu::Precision precision)
 236 {
 237         switch (precision)
 238         {
 239                 case glu::PRECISION_HIGHP:              return -126;
 240                 case glu::PRECISION_MEDIUMP:    return -14;
 241                 case glu::PRECISION_LOWP:               return -8;
 242                 default:
 243                         DE_ASSERT(false);
 244                         return 0;
 245         }
 246 }
 247
 248 static float getSingleULPForExponent (int exp, int numMantissaBits)
 249 {
 250         if (numMantissaBits > 0)
 251         {
 252                 DE_ASSERT(numMantissaBits <= 23);
 253
 254                 const int ulpBitNdx = 23-numMantissaBits;
 255                 return tcu::Float32::construct(+1, exp, (1<<23) | (1 << ulpBitNdx)).asFloat() - tcu::Float32::construct(+1, exp, (1<<23)).asFloat();
 256         }
 257         else
 258         {
 259                 DE_ASSERT(numMantissaBits == 0);
 260                 return tcu::Float32::construct(+1, exp, (1<<23)).asFloat();
 261         }
 262 }
 263
 264 static float getSingleULPForValue (float value, int numMantissaBits)
 265 {
 266         const int exp = tcu::Float32(value).exponent();
 267         return getSingleULPForExponent(exp, numMantissaBits);
 268 }
 269
 270 static float convertFloatFlushToZeroRtn (float value, int minExponent, int numAccurateBits)
 271 {
 272         if (value == 0.0f)
 273         {
 274                 return 0.0f;
 275         }
 276         else
 277         {
 278                 const tcu::Float32      inputFloat                      = tcu::Float32(value);
 279                 const int                       numTruncatedBits        = 23-numAccurateBits;
 280                 const deUint32          truncMask                       = (1u<<numTruncatedBits)-1u;
 281
 282                 if (value > 0.0f)
 283                 {
 284                         if (value > 0.0f && tcu::Float32(value).exponent() < minExponent)
 285                         {
 286                                 // flush to zero if possible
 287                                 return 0.0f;
 288                         }
 289                         else
 290                         {
 291                                 // just mask away non-representable bits
 292                                 return tcu::Float32::construct(+1, inputFloat.exponent(), inputFloat.mantissa() & ~truncMask).asFloat();
 293                         }
 294                 }
 295                 else
 296                 {
 297                         if (inputFloat.mantissa() & truncMask)
 298                         {
 299                                 // decrement one ulp if truncated bits are non-zero (i.e. if value is not representable)
 300                                 return tcu::Float32::construct(-1, inputFloat.exponent(), inputFloat.mantissa() & ~truncMask).asFloat() - getSingleULPForExponent(inputFloat.exponent(), numAccurateBits);
 301                         }
 302                         else
 303                         {
 304                                 // value is representable, no need to do anything
 305                                 return value;
 306                         }
 307                 }
 308         }
 309 }
 310
 311 static float convertFloatFlushToZeroRtp (float value, int minExponent, int numAccurateBits)
 312 {
 313         return -convertFloatFlushToZeroRtn(-value, minExponent, numAccurateBits);
 314 }
 315
 316 static float addErrorUlp (float value, float numUlps, int numMantissaBits)
 317 {
 318         return value + numUlps * getSingleULPForValue(value, numMantissaBits);
 319 }
 320
 321 enum
 322 {
 323         INTERPOLATION_LOST_BITS = 3, // number mantissa of bits allowed to be lost in varying interpolation
 324 };
 325
 326 static inline tcu::Vec4 getDerivateThreshold (const glu::Precision precision, const tcu::Vec4& valueMin, const tcu::Vec4& valueMax, const tcu::Vec4& expectedDerivate)
 327 {
 328         const int                       baseBits                = getNumMantissaBits(precision);
 329         const tcu::UVec4        derivExp                = getCompExpBits(expectedDerivate);
 330         const tcu::UVec4        maxValueExp             = max(getCompExpBits(valueMin), getCompExpBits(valueMax));
 331         const tcu::UVec4        numBitsLost             = maxValueExp - min(maxValueExp, derivExp);
 332         const tcu::IVec4        numAccurateBits = max(baseBits - numBitsLost.asInt() - (int)INTERPOLATION_LOST_BITS, tcu::IVec4(0));
 333
 334         return tcu::Vec4(computeFloatingPointError(expectedDerivate[0], numAccurateBits[0]),
 335                                          computeFloatingPointError(expectedDerivate[1], numAccurateBits[1]),
 336                                          computeFloatingPointError(expectedDerivate[2], numAccurateBits[2]),
 337                                          computeFloatingPointError(expectedDerivate[3], numAccurateBits[3]));
 338 }
 339
 340 namespace
 341 {
 342
 343 struct LogVecComps
 344 {
 345         const tcu::Vec4&        v;
 346         int                                     numComps;
 347
 348         LogVecComps (const tcu::Vec4& v_, int numComps_)
 349                 : v                     (v_)
 350                 , numComps      (numComps_)
 351         {
 352         }
 353 };
 354
 355 std::ostream& operator<< (std::ostream& str, const LogVecComps& v)
 356 {
 357         DE_ASSERT(de::inRange(v.numComps, 1, 4));
 358         if (v.numComps == 1)            return str << v.v[0];
 359         else if (v.numComps == 2)       return str << v.v.toWidth<2>();
 360         else if (v.numComps == 3)       return str << v.v.toWidth<3>();
 361         else                                            return str << v.v;
 362 }
 363
 364 } // anonymous
 365
 366 enum VerificationLogging
 367 {
 368         LOG_ALL = 0,
 369         LOG_NOTHING
 370 };
 371
 372 static bool verifyConstantDerivate (tcu::TestLog&                                               log,
 373                                                                         const tcu::ConstPixelBufferAccess&      result,
 374                                                                         const tcu::PixelBufferAccess&           errorMask,
 375                                                                         glu::DataType                                           dataType,
 376                                                                         const tcu::Vec4&                                        reference,
 377                                                                         const tcu::Vec4&                                        threshold,
 378                                                                         const tcu::Vec4&                                        scale,
 379                                                                         const tcu::Vec4&                                        bias,
 380                                                                         VerificationLogging                                     logPolicy = LOG_ALL)
 381 {
 382         const int                       numComps                = glu::getDataTypeFloatScalars(dataType);
 383         const tcu::BVec4        mask                    = tcu::logicalNot(getDerivateMask(dataType));
 384         int                                     numFailedPixels = 0;
 385
 386         if (logPolicy == LOG_ALL)
 387                 log << TestLog::Message << "Expecting " << LogVecComps(reference, numComps) << " with threshold " << LogVecComps(threshold, numComps) << TestLog::EndMessage;
 388
 389         for (int y = 0; y < result.getHeight(); y++)
 390         {
 391                 for (int x = 0; x < result.getWidth(); x++)
 392                 {
 393                         const tcu::Vec4         resDerivate             = readDerivate(result, scale, bias, x, y);
 394                         const bool                      isOk                    = tcu::allEqual(tcu::logicalOr(tcu::lessThanEqual(tcu::abs(reference - resDerivate), threshold), mask), tcu::BVec4(true));
 395
 396                         if (!isOk)
 397                         {
 398                                 if (numFailedPixels < MAX_FAILED_MESSAGES && logPolicy == LOG_ALL)
 399                                         log << TestLog::Message << "FAIL: got " << LogVecComps(resDerivate, numComps)
 400                                                                                         << ", diff = " << LogVecComps(tcu::abs(reference - resDerivate), numComps)
 401                                                                                         << ", at x = " << x << ", y = " << y
 402                                                 << TestLog::EndMessage;
 403                                 numFailedPixels += 1;
 404                                 errorMask.setPixel(tcu::RGBA::red().toVec(), x, y);
 405                         }
 406                 }
 407         }
 408
 409         if (numFailedPixels >= MAX_FAILED_MESSAGES && logPolicy == LOG_ALL)
 410                 log << TestLog::Message << "..." << TestLog::EndMessage;
 411
 412         if (numFailedPixels > 0 && logPolicy == LOG_ALL)
 413                 log << TestLog::Message << "FAIL: found " << numFailedPixels << " failed pixels" << TestLog::EndMessage;
 414
 415         return numFailedPixels == 0;
 416 }
 417
 418 struct Linear2DFunctionEvaluator
 419 {
 420         tcu::Matrix<float, 4, 3> matrix;
 421
 422         //      .-----.
 423         //      | s_x |
 424         //  M x | s_y |
 425         //      | 1.0 |
 426         //      '-----'
 427         tcu::Vec4 evaluateAt (float screenX, float screenY) const;
 428 };
 429
 430 tcu::Vec4 Linear2DFunctionEvaluator::evaluateAt (float screenX, float screenY) const
 431 {
 432         const tcu::Vec3 position(screenX, screenY, 1.0f);
 433         return matrix * position;
 434 }
 435
 436 static bool reverifyConstantDerivateWithFlushRelaxations (tcu::TestLog&                                                 log,
 437                                                                                                                   const tcu::ConstPixelBufferAccess&    result,
 438                                                                                                                   const tcu::PixelBufferAccess&                 errorMask,
 439                                                                                                                   glu::DataType                                                 dataType,
 440                                                                                                                   glu::Precision                                                precision,
 441                                                                                                                   const tcu::Vec4&                                              derivScale,
 442                                                                                                                   const tcu::Vec4&                                              derivBias,
 443                                                                                                                   const tcu::Vec4&                                              surfaceThreshold,
 444                                                                                                                   DerivateFunc                                                  derivateFunc,
 445                                                                                                                   const Linear2DFunctionEvaluator&              function)
 446 {
 447         DE_ASSERT(result.getWidth() == errorMask.getWidth());
 448         DE_ASSERT(result.getHeight() == errorMask.getHeight());
 449         DE_ASSERT(derivateFunc == DERIVATE_DFDX || derivateFunc == DERIVATE_DFDY);
 450
 451         const tcu::IVec4        red                                             (255, 0, 0, 255);
 452         const tcu::IVec4        green                                   (0, 255, 0, 255);
 453         const float                     divisionErrorUlps               = 2.5f;
 454
 455         const int                       numComponents                   = glu::getDataTypeFloatScalars(dataType);
 456         const int                       numBits                                 = getNumMantissaBits(precision);
 457         const int                       minExponent                             = getMinExponent(precision);
 458
 459         const int                       numVaryingSampleBits    = numBits - INTERPOLATION_LOST_BITS;
 460         int                                     numFailedPixels                 = 0;
 461
 462         tcu::clear(errorMask, green);
 463
 464         // search for failed pixels
 465         for (int y = 0; y < result.getHeight(); ++y)
 466         for (int x = 0; x < result.getWidth(); ++x)
 467         {
 468                 //                 flushToZero?(f2z?(functionValueCurrent) - f2z?(functionValueBefore))
 469                 // flushToZero? ( ------------------------------------------------------------------------ +- 2.5 ULP )
 470                 //                                                  dx
 471
 472                 const tcu::Vec4 resultDerivative                = readDerivate(result, derivScale, derivBias, x, y);
 473
 474                 // sample at the front of the back pixel and the back of the front pixel to cover the whole area of
 475                 // legal sample positions. In general case this is NOT OK, but we know that the target funtion is
 476                 // (mostly*) linear which allows us to take the sample points at arbitrary points. This gets us the
 477                 // maximum difference possible in exponents which are used in error bound calculations.
 478                 // * non-linearity may happen around zero or with very high function values due to subnorms not
 479                 //   behaving well.
 480                 const tcu::Vec4 functionValueForward    = (derivateFunc == DERIVATE_DFDX)
 481                                                                                                         ? (function.evaluateAt((float)x + 2.0f, (float)y + 0.5f))
 482                                                                                                         : (function.evaluateAt((float)x + 0.5f, (float)y + 2.0f));
 483                 const tcu::Vec4 functionValueBackward   = (derivateFunc == DERIVATE_DFDX)
 484                                                                                                         ? (function.evaluateAt((float)x - 1.0f, (float)y + 0.5f))
 485                                                                                                         : (function.evaluateAt((float)x + 0.5f, (float)y - 1.0f));
 486
 487                 bool    anyComponentFailed                              = false;
 488
 489                 // check components separately
 490                 for (int c = 0; c < numComponents; ++c)
 491                 {
 492                         // Simulate interpolation. Add allowed interpolation error and round to target precision. Allow one half ULP (i.e. correct rounding)
 493                         const tcu::Interval     forwardComponent                (convertFloatFlushToZeroRtn(addErrorUlp((float)functionValueForward[c],  -0.5f, numVaryingSampleBits), minExponent, numBits),
 494                                                                                                                  convertFloatFlushToZeroRtp(addErrorUlp((float)functionValueForward[c],  +0.5f, numVaryingSampleBits), minExponent, numBits));
 495                         const tcu::Interval     backwardComponent               (convertFloatFlushToZeroRtn(addErrorUlp((float)functionValueBackward[c], -0.5f, numVaryingSampleBits), minExponent, numBits),
 496                                                                                                                  convertFloatFlushToZeroRtp(addErrorUlp((float)functionValueBackward[c], +0.5f, numVaryingSampleBits), minExponent, numBits));
 497                         const int                       maxValueExp                             = de::max(de::max(tcu::Float32(forwardComponent.lo()).exponent(),   tcu::Float32(forwardComponent.hi()).exponent()),
 498                                                                                                                                   de::max(tcu::Float32(backwardComponent.lo()).exponent(),  tcu::Float32(backwardComponent.hi()).exponent()));
 499
 500                         // subtraction in numerator will likely cause a cancellation of the most
 501                         // significant bits. Apply error bounds.
 502
 503                         const tcu::Interval     numerator                               (forwardComponent - backwardComponent);
 504                         const int                       numeratorLoExp                  = tcu::Float32(numerator.lo()).exponent();
 505                         const int                       numeratorHiExp                  = tcu::Float32(numerator.hi()).exponent();
 506                         const int                       numeratorLoBitsLost             = de::max(0, maxValueExp - numeratorLoExp); //!< must clamp to zero since if forward and backward components have different
 507                         const int                       numeratorHiBitsLost             = de::max(0, maxValueExp - numeratorHiExp); //!< sign, numerator might have larger exponent than its operands.
 508                         const int                       numeratorLoBits                 = de::max(0, numBits - numeratorLoBitsLost);
 509                         const int                       numeratorHiBits                 = de::max(0, numBits - numeratorHiBitsLost);
 510
 511                         const tcu::Interval     numeratorRange                  (convertFloatFlushToZeroRtn((float)numerator.lo(), minExponent, numeratorLoBits),
 512                                                                                                                  convertFloatFlushToZeroRtp((float)numerator.hi(), minExponent, numeratorHiBits));
 513
 514                         const tcu::Interval     divisionRange                   = numeratorRange / 3.0f; // legal sample area is anywhere within this and neighboring pixels (i.e. size = 3)
 515                         const tcu::Interval     divisionResultRange             (convertFloatFlushToZeroRtn(addErrorUlp((float)divisionRange.lo(), -divisionErrorUlps, numBits), minExponent, numBits),
 516                                                                                                                  convertFloatFlushToZeroRtp(addErrorUlp((float)divisionRange.hi(), +divisionErrorUlps, numBits), minExponent, numBits));
 517                         const tcu::Interval     finalResultRange                (divisionResultRange.lo() - surfaceThreshold[c], divisionResultRange.hi() + surfaceThreshold[c]);
 518
 519                         if (resultDerivative[c] >= finalResultRange.lo() && resultDerivative[c] <= finalResultRange.hi())
 520                         {
 521                                 // value ok
 522                         }
 523                         else
 524                         {
 525                                 if (numFailedPixels < MAX_FAILED_MESSAGES)
 526                                         log << tcu::TestLog::Message
 527                                                 << "Error in pixel at " << x << ", " << y << " with component " << c << " (channel " << ("rgba"[c]) << ")\n"
 528                                                 << "\tGot pixel value " << result.getPixelInt(x, y) << "\n"
 529                                                 << "\t\tdFd" << ((derivateFunc == DERIVATE_DFDX) ? ('x') : ('y')) << " ~= " << resultDerivative[c] << "\n"
 530                                                 << "\t\tdifference to a valid range: "
 531                                                         << ((resultDerivative[c] < finalResultRange.lo()) ? ("-") : ("+"))
 532                                                         << ((resultDerivative[c] < finalResultRange.lo()) ? (finalResultRange.lo() - resultDerivative[c]) : (resultDerivative[c] - finalResultRange.hi()))
 533                                                         << "\n"
 534                                                 << "\tDerivative value range:\n"
 535                                                 << "\t\tMin: " << finalResultRange.lo() << "\n"
 536                                                 << "\t\tMax: " << finalResultRange.hi() << "\n"
 537                                                 << tcu::TestLog::EndMessage;
 538
 539                                 ++numFailedPixels;
 540                                 anyComponentFailed = true;
 541                         }
 542                 }
 543
 544                 if (anyComponentFailed)
 545                         errorMask.setPixel(red, x, y);
 546         }
 547
 548         if (numFailedPixels >= MAX_FAILED_MESSAGES)
 549                 log << TestLog::Message << "..." << TestLog::EndMessage;
 550
 551         if (numFailedPixels > 0)
 552                 log << TestLog::Message << "FAIL: found " << numFailedPixels << " failed pixels" << TestLog::EndMessage;
 553
 554         return numFailedPixels == 0;
 555 }
 556
 557 // TriangleDerivateCase
 558
 559 class TriangleDerivateCase : public TestCase
 560 {
 561 public:
 562                                                 TriangleDerivateCase    (Context& context, const char* name, const char* description);
 563                                                 ~TriangleDerivateCase   (void);
 564
 565         IterateResult           iterate                                 (void);
 566
 567 protected:
 568         virtual void            setupRenderState                (deUint32 program) { DE_UNREF(program); }
 569         virtual bool            verify                                  (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask) = DE_NULL;
 570
 571         tcu::IVec2                      getViewportSize                 (void) const;
 572         tcu::Vec4                       getSurfaceThreshold             (void) const;
 573
 574         glu::DataType           m_dataType;
 575         glu::Precision          m_precision;
 576
 577         glu::DataType           m_coordDataType;
 578         glu::Precision          m_coordPrecision;
 579
 580         std::string                     m_fragmentSrc;
 581
 582         tcu::Vec4                       m_coordMin;
 583         tcu::Vec4                       m_coordMax;
 584         tcu::Vec4                       m_derivScale;
 585         tcu::Vec4                       m_derivBias;
 586
 587         SurfaceType                     m_surfaceType;
 588         int                                     m_numSamples;
 589         deUint32                        m_hint;
 590 };
 591
 592 TriangleDerivateCase::TriangleDerivateCase (Context& context, const char* name, const char* description)
 593         : TestCase                      (context, name, description)
 594         , m_dataType            (glu::TYPE_LAST)
 595         , m_precision           (glu::PRECISION_LAST)
 596         , m_coordDataType       (glu::TYPE_LAST)
 597         , m_coordPrecision      (glu::PRECISION_LAST)
 598         , m_surfaceType         (SURFACETYPE_DEFAULT_FRAMEBUFFER)
 599         , m_numSamples          (0)
 600         , m_hint                        (GL_DONT_CARE)
 601 {
 602         DE_ASSERT(m_surfaceType != SURFACETYPE_DEFAULT_FRAMEBUFFER || m_numSamples == 0);
 603 }
 604
 605 TriangleDerivateCase::~TriangleDerivateCase (void)
 606 {
 607         TriangleDerivateCase::deinit();
 608 }
 609
 610 static std::string genVertexSource (glu::DataType coordType, glu::Precision precision)
 611 {
 612         DE_ASSERT(glu::isDataTypeFloatOrVec(coordType));
 613
 614         const char* vertexTmpl =
 615                 "#version 300 es\n"
 616                 "in highp vec4 a_position;\n"
 617                 "in ${PRECISION} ${DATATYPE} a_coord;\n"
 618                 "out ${PRECISION} ${DATATYPE} v_coord;\n"
 619                 "void main (void)\n"
 620                 "{\n"
 621                 "       gl_Position = a_position;\n"
 622                 "       v_coord = a_coord;\n"
 623                 "}\n";
 624
 625         map<string, string> vertexParams;
 626
 627         vertexParams["PRECISION"]       = glu::getPrecisionName(precision);
 628         vertexParams["DATATYPE"]        = glu::getDataTypeName(coordType);
 629
 630         return tcu::StringTemplate(vertexTmpl).specialize(vertexParams);
 631 }
 632
 633 inline tcu::IVec2 TriangleDerivateCase::getViewportSize (void) const
 634 {
 635         if (m_surfaceType == SURFACETYPE_DEFAULT_FRAMEBUFFER)
 636         {
 637                 const int       width   = de::min<int>(m_context.getRenderTarget().getWidth(),  VIEWPORT_WIDTH);
 638                 const int       height  = de::min<int>(m_context.getRenderTarget().getHeight(), VIEWPORT_HEIGHT);
 639                 return tcu::IVec2(width, height);
 640         }
 641         else
 642                 return tcu::IVec2(FBO_WIDTH, FBO_HEIGHT);
 643 }
 644
 645 TriangleDerivateCase::IterateResult TriangleDerivateCase::iterate (void)
 646 {
 647         const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
 648         const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::makeVtxFragSources(genVertexSource(m_coordDataType, m_coordPrecision), m_fragmentSrc));
 649         de::Random                                      rnd                             (deStringHash(getName()) ^ 0xbbc24);
 650         const bool                                      useFbo                  = m_surfaceType != SURFACETYPE_DEFAULT_FRAMEBUFFER;
 651         const deUint32                          fboFormat               = m_surfaceType == SURFACETYPE_FLOAT_FBO ? GL_RGBA32UI : GL_RGBA8;
 652         const tcu::IVec2                        viewportSize    = getViewportSize();
 653         const int                                       viewportX               = useFbo ? 0 : rnd.getInt(0, m_context.getRenderTarget().getWidth()             - viewportSize.x());
 654         const int                                       viewportY               = useFbo ? 0 : rnd.getInt(0, m_context.getRenderTarget().getHeight()    - viewportSize.y());
 655         AutoFbo                                         fbo                             (gl);
 656         AutoRbo                                         rbo                             (gl);
 657         tcu::TextureLevel                       result;
 658
 659         m_testCtx.getLog() << program;
 660
 661         if (!program.isOk())
 662                 TCU_FAIL("Compile failed");
 663
 664         if (useFbo)
 665         {
 666                 m_testCtx.getLog() << TestLog::Message
 667                                                    << "Rendering to FBO, format = " << glu::getTextureFormatStr(fboFormat)
 668                                                    << ", samples = " << m_numSamples
 669                                                    << TestLog::EndMessage;
 670
 671                 fbo.gen();
 672                 rbo.gen();
 673
 674                 gl.bindRenderbuffer(GL_RENDERBUFFER, *rbo);
 675                 gl.renderbufferStorageMultisample(GL_RENDERBUFFER, m_numSamples, fboFormat, viewportSize.x(), viewportSize.y());
 676                 gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
 677                 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *rbo);
 678                 TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 679         }
 680         else
 681         {
 682                 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();
 683
 684                 m_testCtx.getLog()
 685                         << TestLog::Message
 686                         << "Rendering to default framebuffer\n"
 687                         << "\tColor depth: R=" << pixelFormat.redBits << ", G=" << pixelFormat.greenBits << ", B=" << pixelFormat.blueBits << ", A=" << pixelFormat.alphaBits
 688                         << TestLog::EndMessage;
 689         }
 690
 691         m_testCtx.getLog() << TestLog::Message << "in: " << m_coordMin << " -> " << m_coordMax << "\n"
 692                                                                                    << "v_coord.x = in.x * x\n"
 693                                                                                    << "v_coord.y = in.y * y\n"
 694                                                                                    << "v_coord.z = in.z * (x+y)/2\n"
 695                                                                                    << "v_coord.w = in.w * (1 - (x+y)/2)\n"
 696                                            << TestLog::EndMessage
 697                                            << TestLog::Message << "u_scale: " << m_derivScale << ", u_bias: " << m_derivBias << " (displayed values have scale/bias removed)" << TestLog::EndMessage
 698                                            << TestLog::Message << "Viewport: " << viewportSize.x() << "x" << viewportSize.y() << TestLog::EndMessage
 699                                            << TestLog::Message << "GL_FRAGMENT_SHADER_DERIVATE_HINT: " << glu::getHintModeStr(m_hint) << TestLog::EndMessage;
 700
 701         // Draw
 702         {
 703                 const float positions[] =
 704                 {
 705                         -1.0f, -1.0f, 0.0f, 1.0f,
 706                         -1.0f,  1.0f, 0.0f, 1.0f,
 707                          1.0f, -1.0f, 0.0f, 1.0f,
 708                          1.0f,  1.0f, 0.0f, 1.0f
 709                 };
 710                 const float coords[] =
 711                 {
 712                         m_coordMin.x(), m_coordMin.y(), m_coordMin.z(),                                                 m_coordMax.w(),
 713                         m_coordMin.x(), m_coordMax.y(), (m_coordMin.z()+m_coordMax.z())*0.5f,   (m_coordMin.w()+m_coordMax.w())*0.5f,
 714                         m_coordMax.x(), m_coordMin.y(), (m_coordMin.z()+m_coordMax.z())*0.5f,   (m_coordMin.w()+m_coordMax.w())*0.5f,
 715                         m_coordMax.x(), m_coordMax.y(), m_coordMax.z(),                                                 m_coordMin.w()
 716                 };
 717                 const glu::VertexArrayBinding vertexArrays[] =
 718                 {
 719                         glu::va::Float("a_position",    4, 4, 0, &positions[0]),
 720                         glu::va::Float("a_coord",               4, 4, 0, &coords[0])
 721                 };
 722                 const deUint16 indices[] = { 0, 2, 1, 2, 3, 1 };
 723
 724                 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f);
 725                 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
 726                 gl.disable(GL_DITHER);
 727
 728                 gl.useProgram(program.getProgram());
 729
 730                 {
 731                         const int       scaleLoc        = gl.getUniformLocation(program.getProgram(), "u_scale");
 732                         const int       biasLoc         = gl.getUniformLocation(program.getProgram(), "u_bias");
 733
 734                         switch (m_dataType)
 735                         {
 736                                 case glu::TYPE_FLOAT:
 737                                         gl.uniform1f(scaleLoc, m_derivScale.x());
 738                                         gl.uniform1f(biasLoc, m_derivBias.x());
 739                                         break;
 740
 741                                 case glu::TYPE_FLOAT_VEC2:
 742                                         gl.uniform2fv(scaleLoc, 1, m_derivScale.getPtr());
 743                                         gl.uniform2fv(biasLoc, 1, m_derivBias.getPtr());
 744                                         break;
 745
 746                                 case glu::TYPE_FLOAT_VEC3:
 747                                         gl.uniform3fv(scaleLoc, 1, m_derivScale.getPtr());
 748                                         gl.uniform3fv(biasLoc, 1, m_derivBias.getPtr());
 749                                         break;
 750
 751                                 case glu::TYPE_FLOAT_VEC4:
 752                                         gl.uniform4fv(scaleLoc, 1, m_derivScale.getPtr());
 753                                         gl.uniform4fv(biasLoc, 1, m_derivBias.getPtr());
 754                                         break;
 755
 756                                 default:
 757                                         DE_ASSERT(false);
 758                         }
 759                 }
 760
 761                 gls::setupDefaultUniforms(m_context.getRenderContext(), program.getProgram());
 762                 setupRenderState(program.getProgram());
 763
 764                 gl.hint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT, m_hint);
 765                 GLU_EXPECT_NO_ERROR(gl.getError(), "Setup program state");
 766
 767                 gl.viewport(viewportX, viewportY, viewportSize.x(), viewportSize.y());
 768                 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
 769                                   glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
 770                 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
 771         }
 772
 773         // Read back results
 774         {
 775                 const bool              isMSAA          = useFbo && m_numSamples > 0;
 776                 AutoFbo                 resFbo          (gl);
 777                 AutoRbo                 resRbo          (gl);
 778
 779                 // Resolve if necessary
 780                 if (isMSAA)
 781                 {
 782                         resFbo.gen();
 783                         resRbo.gen();
 784
 785                         gl.bindRenderbuffer(GL_RENDERBUFFER, *resRbo);
 786                         gl.renderbufferStorageMultisample(GL_RENDERBUFFER, 0, fboFormat, viewportSize.x(), viewportSize.y());
 787                         gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, *resFbo);
 788                         gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *resRbo);
 789                         TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 790
 791                         gl.blitFramebuffer(0, 0, viewportSize.x(), viewportSize.y(), 0, 0, viewportSize.x(), viewportSize.y(), GL_COLOR_BUFFER_BIT, GL_NEAREST);
 792                         GLU_EXPECT_NO_ERROR(gl.getError(), "Resolve blit");
 793
 794                         gl.bindFramebuffer(GL_READ_FRAMEBUFFER, *resFbo);
 795                 }
 796
 797                 switch (m_surfaceType)
 798                 {
 799                         case SURFACETYPE_DEFAULT_FRAMEBUFFER:
 800                         case SURFACETYPE_UNORM_FBO:
 801                                 result.setStorage(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), viewportSize.x(), viewportSize.y());
 802                                 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, result);
 803                                 break;
 804
 805                         case SURFACETYPE_FLOAT_FBO:
 806                         {
 807                                 const tcu::TextureFormat        dataFormat              (tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT);
 808                                 const tcu::TextureFormat        transferFormat  (tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32);
 809
 810                                 result.setStorage(dataFormat, viewportSize.x(), viewportSize.y());
 811                                 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY,
 812                                                                 tcu::PixelBufferAccess(transferFormat, result.getWidth(), result.getHeight(), result.getDepth(), result.getAccess().getDataPtr()));
 813                                 break;
 814                         }
 815
 816                         default:
 817                                 DE_ASSERT(false);
 818                 }
 819
 820                 GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
 821         }
 822
 823         // Verify
 824         {
 825                 tcu::Surface errorMask(result.getWidth(), result.getHeight());
 826                 tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec());
 827
 828                 const bool isOk = verify(result.getAccess(), errorMask.getAccess());
 829
 830                 m_testCtx.getLog() << TestLog::ImageSet("Result", "Result images")
 831                                                    << TestLog::Image("Rendered", "Rendered image", result);
 832
 833                 if (!isOk)
 834                         m_testCtx.getLog() << TestLog::Image("ErrorMask", "Error mask", errorMask);
 835
 836                 m_testCtx.getLog() << TestLog::EndImageSet;
 837
 838                 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS      : QP_TEST_RESULT_FAIL,
 839                                                                 isOk ? "Pass"                           : "Image comparison failed");
 840         }
 841
 842         return STOP;
 843 }
 844
 845 tcu::Vec4 TriangleDerivateCase::getSurfaceThreshold (void) const
 846 {
 847         switch (m_surfaceType)
 848         {
 849                 case SURFACETYPE_DEFAULT_FRAMEBUFFER:
 850                 {
 851                         const tcu::PixelFormat  pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 852                         const tcu::IVec4                channelBits             (pixelFormat.redBits, pixelFormat.greenBits, pixelFormat.blueBits, pixelFormat.alphaBits);
 853                         const tcu::IVec4                intThreshold    = tcu::IVec4(1) << (8 - channelBits);
 854                         const tcu::Vec4                 normThreshold   = intThreshold.asFloat() / 255.0f;
 855
 856                         return normThreshold;
 857                 }
 858
 859                 case SURFACETYPE_UNORM_FBO:                             return tcu::IVec4(1).asFloat() / 255.0f;
 860                 case SURFACETYPE_FLOAT_FBO:                             return tcu::Vec4(0.0f);
 861                 default:
 862                         DE_ASSERT(false);
 863                         return tcu::Vec4(0.0f);
 864         }
 865 }
 866
 867 // ConstantDerivateCase
 868
 869 class ConstantDerivateCase : public TriangleDerivateCase
 870 {
 871 public:
 872                                                 ConstantDerivateCase            (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type);
 873                                                 ~ConstantDerivateCase           (void) {}
 874
 875         void                            init                                            (void);
 876
 877 protected:
 878         bool                            verify                                          (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
 879
 880 private:
 881         DerivateFunc            m_func;
 882 };
 883
 884 ConstantDerivateCase::ConstantDerivateCase (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type)
 885         : TriangleDerivateCase  (context, name, description)
 886         , m_func                                (func)
 887 {
 888         m_dataType                      = type;
 889         m_precision                     = glu::PRECISION_HIGHP;
 890         m_coordDataType         = m_dataType;
 891         m_coordPrecision        = m_precision;
 892 }
 893
 894 void ConstantDerivateCase::init (void)
 895 {
 896         const char* fragmentTmpl =
 897                 "#version 300 es\n"
 898                 "layout(location = 0) out mediump vec4 o_color;\n"
 899                 "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
 900                 "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
 901                 "void main (void)\n"
 902                 "{\n"
 903                 "       ${PRECISION} ${DATATYPE} res = ${FUNC}(${VALUE}) * u_scale + u_bias;\n"
 904                 "       o_color = ${CAST_TO_OUTPUT};\n"
 905                 "}\n";
 906         map<string, string> fragmentParams;
 907         fragmentParams["PRECISION"]                     = glu::getPrecisionName(m_precision);
 908         fragmentParams["DATATYPE"]                      = glu::getDataTypeName(m_dataType);
 909         fragmentParams["FUNC"]                          = getDerivateFuncName(m_func);
 910         fragmentParams["VALUE"]                         = m_dataType == glu::TYPE_FLOAT_VEC4 ? "vec4(1.0, 7.2, -1e5, 0.0)" :
 911                                                                                   m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec3(1e2, 8.0, 0.01)" :
 912                                                                                   m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec2(-0.0, 2.7)" :
 913                                                                                   /* TYPE_FLOAT */                                         "7.7";
 914         fragmentParams["CAST_TO_OUTPUT"]        = m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
 915                                                                                   m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
 916                                                                                   m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
 917                                                                                   /* TYPE_FLOAT */                                         "vec4(res, 0.0, 0.0, 1.0)";
 918
 919         m_fragmentSrc = tcu::StringTemplate(fragmentTmpl).specialize(fragmentParams);
 920
 921         m_derivScale    = tcu::Vec4(1e3f, 1e3f, 1e3f, 1e3f);
 922         m_derivBias             = tcu::Vec4(0.5f, 0.5f, 0.5f, 0.5f);
 923 }
 924
 925 bool ConstantDerivateCase::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
 926 {
 927         const tcu::Vec4 reference       (0.0f); // Derivate of constant argument should always be 0
 928         const tcu::Vec4 threshold       = getSurfaceThreshold() / abs(m_derivScale);
 929
 930         return verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType,
 931                                                                   reference, threshold, m_derivScale, m_derivBias);
 932 }
 933
 934 // LinearDerivateCase
 935
 936 class LinearDerivateCase : public TriangleDerivateCase
 937 {
 938 public:
 939                                                 LinearDerivateCase              (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type, glu::Precision precision, deUint32 hint, SurfaceType surfaceType, int numSamples, const char* fragmentSrcTmpl);
 940                                                 ~LinearDerivateCase             (void) {}
 941
 942         void                            init                                    (void);
 943
 944 protected:
 945         bool                            verify                                  (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
 946
 947 private:
 948         DerivateFunc            m_func;
 949         std::string                     m_fragmentTmpl;
 950 };
 951
 952 LinearDerivateCase::LinearDerivateCase (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type, glu::Precision precision, deUint32 hint, SurfaceType surfaceType, int numSamples, const char* fragmentSrcTmpl)
 953         : TriangleDerivateCase  (context, name, description)
 954         , m_func                                (func)
 955         , m_fragmentTmpl                (fragmentSrcTmpl)
 956 {
 957         m_dataType                      = type;
 958         m_precision                     = precision;
 959         m_coordDataType         = m_dataType;
 960         m_coordPrecision        = m_precision;
 961         m_hint                          = hint;
 962         m_surfaceType           = surfaceType;
 963         m_numSamples            = numSamples;
 964 }
 965
 966 void LinearDerivateCase::init (void)
 967 {
 968         const tcu::IVec2        viewportSize    = getViewportSize();
 969         const float                     w                               = float(viewportSize.x());
 970         const float                     h                               = float(viewportSize.y());
 971         const bool                      packToInt               = m_surfaceType == SURFACETYPE_FLOAT_FBO;
 972         map<string, string>     fragmentParams;
 973
 974         fragmentParams["OUTPUT_TYPE"]           = glu::getDataTypeName(packToInt ? glu::TYPE_UINT_VEC4 : glu::TYPE_FLOAT_VEC4);
 975         fragmentParams["OUTPUT_PREC"]           = glu::getPrecisionName(packToInt ? glu::PRECISION_HIGHP : m_precision);
 976         fragmentParams["PRECISION"]                     = glu::getPrecisionName(m_precision);
 977         fragmentParams["DATATYPE"]                      = glu::getDataTypeName(m_dataType);
 978         fragmentParams["FUNC"]                          = getDerivateFuncName(m_func);
 979
 980         if (packToInt)
 981         {
 982                 fragmentParams["CAST_TO_OUTPUT"]        = m_dataType == glu::TYPE_FLOAT_VEC4 ? "floatBitsToUint(res)" :
 983                                                                                           m_dataType == glu::TYPE_FLOAT_VEC3 ? "floatBitsToUint(vec4(res, 1.0))" :
 984                                                                                           m_dataType == glu::TYPE_FLOAT_VEC2 ? "floatBitsToUint(vec4(res, 0.0, 1.0))" :
 985                                                                                           /* TYPE_FLOAT */                                         "floatBitsToUint(vec4(res, 0.0, 0.0, 1.0))";
 986         }
 987         else
 988         {
 989                 fragmentParams["CAST_TO_OUTPUT"]        = m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
 990                                                                                           m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
 991                                                                                           m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
 992                                                                                           /* TYPE_FLOAT */                                         "vec4(res, 0.0, 0.0, 1.0)";
 993         }
 994
 995         m_fragmentSrc = tcu::StringTemplate(m_fragmentTmpl.c_str()).specialize(fragmentParams);
 996
 997         switch (m_precision)
 998         {
 999                 case glu::PRECISION_HIGHP:
1000                         m_coordMin = tcu::Vec4(-97.f, 0.2f, 71.f, 74.f);
1001                         m_coordMax = tcu::Vec4(-13.2f, -77.f, 44.f, 76.f);
1002                         break;
1003
1004                 case glu::PRECISION_MEDIUMP:
1005                         m_coordMin = tcu::Vec4(-37.0f, 47.f, -7.f, 0.0f);
1006                         m_coordMax = tcu::Vec4(-1.0f, 12.f, 7.f, 19.f);
1007                         break;
1008
1009                 case glu::PRECISION_LOWP:
1010                         m_coordMin = tcu::Vec4(0.0f, -1.0f, 0.0f, 1.0f);
1011                         m_coordMax = tcu::Vec4(1.0f, 1.0f, -1.0f, -1.0f);
1012                         break;
1013
1014                 default:
1015                         DE_ASSERT(false);
1016         }
1017
1018         if (m_surfaceType == SURFACETYPE_FLOAT_FBO)
1019         {
1020                 // No scale or bias used for accuracy.
1021                 m_derivScale    = tcu::Vec4(1.0f);
1022                 m_derivBias             = tcu::Vec4(0.0f);
1023         }
1024         else
1025         {
1026                 // Compute scale - bias that normalizes to 0..1 range.
1027                 const tcu::Vec4 dx = (m_coordMax - m_coordMin) / tcu::Vec4(w, w, w*0.5f, -w*0.5f);
1028                 const tcu::Vec4 dy = (m_coordMax - m_coordMin) / tcu::Vec4(h, h, h*0.5f, -h*0.5f);
1029
1030                 switch (m_func)
1031                 {
1032                         case DERIVATE_DFDX:
1033                                 m_derivScale = 0.5f / dx;
1034                                 break;
1035
1036                         case DERIVATE_DFDY:
1037                                 m_derivScale = 0.5f / dy;
1038                                 break;
1039
1040                         case DERIVATE_FWIDTH:
1041                                 m_derivScale = 0.5f / (tcu::abs(dx) + tcu::abs(dy));
1042                                 break;
1043
1044                         default:
1045                                 DE_ASSERT(false);
1046                 }
1047
1048                 m_derivBias = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
1049         }
1050 }
1051
1052 bool LinearDerivateCase::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
1053 {
1054         const tcu::Vec4         xScale                          = tcu::Vec4(1.0f, 0.0f, 0.5f, -0.5f);
1055         const tcu::Vec4         yScale                          = tcu::Vec4(0.0f, 1.0f, 0.5f, -0.5f);
1056         const tcu::Vec4         surfaceThreshold        = getSurfaceThreshold() / abs(m_derivScale);
1057
1058         if (m_func == DERIVATE_DFDX || m_func == DERIVATE_DFDY)
1059         {
1060                 const bool                      isX                     = m_func == DERIVATE_DFDX;
1061                 const float                     div                     = isX ? float(result.getWidth()) : float(result.getHeight());
1062                 const tcu::Vec4         scale           = isX ? xScale : yScale;
1063                 const tcu::Vec4         reference       = ((m_coordMax - m_coordMin) / div) * scale;
1064                 const tcu::Vec4         opThreshold     = getDerivateThreshold(m_precision, m_coordMin*scale, m_coordMax*scale, reference);
1065                 const tcu::Vec4         threshold       = max(surfaceThreshold, opThreshold);
1066                 const int                       numComps        = glu::getDataTypeFloatScalars(m_dataType);
1067
1068                 m_testCtx.getLog()
1069                         << tcu::TestLog::Message
1070                         << "Verifying result image.\n"
1071                         << "\tValid derivative is " << LogVecComps(reference, numComps) << " with threshold " << LogVecComps(threshold, numComps)
1072                         << tcu::TestLog::EndMessage;
1073
1074                 // short circuit if result is strictly within the normal value error bounds.
1075                 // This improves performance significantly.
1076                 if (verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType,
1077                                                                    reference, threshold, m_derivScale, m_derivBias,
1078                                                                    LOG_NOTHING))
1079                 {
1080                         m_testCtx.getLog()
1081                                 << tcu::TestLog::Message
1082                                 << "No incorrect derivatives found, result valid."
1083                                 << tcu::TestLog::EndMessage;
1084
1085                         return true;
1086                 }
1087
1088                 // some pixels exceed error bounds calculated for normal values. Verify that these
1089                 // potentially invalid pixels are in fact valid due to (for example) subnorm flushing.
1090
1091                 m_testCtx.getLog()
1092                         << tcu::TestLog::Message
1093                         << "Initial verification failed, verifying image by calculating accurate error bounds for each result pixel.\n"
1094                         << "\tVerifying each result derivative is within its range of legal result values."
1095                         << tcu::TestLog::EndMessage;
1096
1097                 {
1098                         const tcu::IVec2                        viewportSize    = getViewportSize();
1099                         const float                                     w                               = float(viewportSize.x());
1100                         const float                                     h                               = float(viewportSize.y());
1101                         const tcu::Vec4                         valueRamp               = (m_coordMax - m_coordMin);
1102                         Linear2DFunctionEvaluator       function;
1103
1104                         function.matrix.setRow(0, tcu::Vec3(valueRamp.x() / w, 0.0f, m_coordMin.x()));
1105                         function.matrix.setRow(1, tcu::Vec3(0.0f, valueRamp.y() / h, m_coordMin.y()));
1106                         function.matrix.setRow(2, tcu::Vec3(valueRamp.z() / w, valueRamp.z() / h, m_coordMin.z() + m_coordMin.z()) / 2.0f);
1107                         function.matrix.setRow(3, tcu::Vec3(-valueRamp.w() / w, -valueRamp.w() / h, m_coordMax.w() + m_coordMax.w()) / 2.0f);
1108
1109                         return reverifyConstantDerivateWithFlushRelaxations(m_testCtx.getLog(), result, errorMask,
1110                                                                                                                                 m_dataType, m_precision, m_derivScale,
1111                                                                                                                                 m_derivBias, surfaceThreshold, m_func,
1112                                                                                                                                 function);
1113                 }
1114         }
1115         else
1116         {
1117                 DE_ASSERT(m_func == DERIVATE_FWIDTH);
1118                 const float                     w                       = float(result.getWidth());
1119                 const float                     h                       = float(result.getHeight());
1120
1121                 const tcu::Vec4         dx                      = ((m_coordMax - m_coordMin) / w) * xScale;
1122                 const tcu::Vec4         dy                      = ((m_coordMax - m_coordMin) / h) * yScale;
1123                 const tcu::Vec4         reference       = tcu::abs(dx) + tcu::abs(dy);
1124                 const tcu::Vec4         dxThreshold     = getDerivateThreshold(m_precision, m_coordMin*xScale, m_coordMax*xScale, dx);
1125                 const tcu::Vec4         dyThreshold     = getDerivateThreshold(m_precision, m_coordMin*yScale, m_coordMax*yScale, dy);
1126                 const tcu::Vec4         threshold       = max(surfaceThreshold, max(dxThreshold, dyThreshold));
1127
1128                 return verifyConstantDerivate(m_testCtx.getLog(), result, errorMask, m_dataType,
1129                                                                           reference, threshold, m_derivScale, m_derivBias);
1130         }
1131 }
1132
1133 // TextureDerivateCase
1134
1135 class TextureDerivateCase : public TriangleDerivateCase
1136 {
1137 public:
1138                                                 TextureDerivateCase             (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type, glu::Precision precision, deUint32 hint, SurfaceType surfaceType, int numSamples);
1139                                                 ~TextureDerivateCase    (void);
1140
1141         void                            init                                    (void);
1142         void                            deinit                                  (void);
1143
1144 protected:
1145         void                            setupRenderState                (deUint32 program);
1146         bool                            verify                                  (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
1147
1148 private:
1149         DerivateFunc            m_func;
1150
1151         tcu::Vec4                       m_texValueMin;
1152         tcu::Vec4                       m_texValueMax;
1153         glu::Texture2D*         m_texture;
1154 };
1155
1156 TextureDerivateCase::TextureDerivateCase (Context& context, const char* name, const char* description, DerivateFunc func, glu::DataType type, glu::Precision precision, deUint32 hint, SurfaceType surfaceType, int numSamples)
1157         : TriangleDerivateCase  (context, name, description)
1158         , m_func                                (func)
1159         , m_texture                             (DE_NULL)
1160 {
1161         m_dataType                      = type;
1162         m_precision                     = precision;
1163         m_coordDataType         = glu::TYPE_FLOAT_VEC2;
1164         m_coordPrecision        = glu::PRECISION_HIGHP;
1165         m_hint                          = hint;
1166         m_surfaceType           = surfaceType;
1167         m_numSamples            = numSamples;
1168 }
1169
1170 TextureDerivateCase::~TextureDerivateCase (void)
1171 {
1172         delete m_texture;
1173 }
1174
1175 void TextureDerivateCase::init (void)
1176 {
1177         // Generate shader
1178         {
1179                 const char* fragmentTmpl =
1180                         "#version 300 es\n"
1181                         "in highp vec2 v_coord;\n"
1182                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1183                         "uniform ${PRECISION} sampler2D u_sampler;\n"
1184                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1185                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1186                         "void main (void)\n"
1187                         "{\n"
1188                         "       ${PRECISION} vec4 tex = texture(u_sampler, v_coord);\n"
1189                         "       ${PRECISION} ${DATATYPE} res = ${FUNC}(tex${SWIZZLE}) * u_scale + u_bias;\n"
1190                         "       o_color = ${CAST_TO_OUTPUT};\n"
1191                         "}\n";
1192
1193                 const bool                      packToInt               = m_surfaceType == SURFACETYPE_FLOAT_FBO;
1194                 map<string, string> fragmentParams;
1195
1196                 fragmentParams["OUTPUT_TYPE"]           = glu::getDataTypeName(packToInt ? glu::TYPE_UINT_VEC4 : glu::TYPE_FLOAT_VEC4);
1197                 fragmentParams["OUTPUT_PREC"]           = glu::getPrecisionName(packToInt ? glu::PRECISION_HIGHP : m_precision);
1198                 fragmentParams["PRECISION"]                     = glu::getPrecisionName(m_precision);
1199                 fragmentParams["DATATYPE"]                      = glu::getDataTypeName(m_dataType);
1200                 fragmentParams["FUNC"]                          = getDerivateFuncName(m_func);
1201                 fragmentParams["SWIZZLE"]                       = m_dataType == glu::TYPE_FLOAT_VEC4 ? "" :
1202                                                                                           m_dataType == glu::TYPE_FLOAT_VEC3 ? ".xyz" :
1203                                                                                           m_dataType == glu::TYPE_FLOAT_VEC2 ? ".xy" :
1204                                                                                           /* TYPE_FLOAT */                                         ".x";
1205
1206                 if (packToInt)
1207                 {
1208                         fragmentParams["CAST_TO_OUTPUT"]        = m_dataType == glu::TYPE_FLOAT_VEC4 ? "floatBitsToUint(res)" :
1209                                                                                                   m_dataType == glu::TYPE_FLOAT_VEC3 ? "floatBitsToUint(vec4(res, 1.0))" :
1210                                                                                                   m_dataType == glu::TYPE_FLOAT_VEC2 ? "floatBitsToUint(vec4(res, 0.0, 1.0))" :
1211                                                                                                   /* TYPE_FLOAT */                                         "floatBitsToUint(vec4(res, 0.0, 0.0, 1.0))";
1212                 }
1213                 else
1214                 {
1215                         fragmentParams["CAST_TO_OUTPUT"]        = m_dataType == glu::TYPE_FLOAT_VEC4 ? "res" :
1216                                                                                                   m_dataType == glu::TYPE_FLOAT_VEC3 ? "vec4(res, 1.0)" :
1217                                                                                                   m_dataType == glu::TYPE_FLOAT_VEC2 ? "vec4(res, 0.0, 1.0)" :
1218                                                                                                   /* TYPE_FLOAT */                                         "vec4(res, 0.0, 0.0, 1.0)";
1219                 }
1220
1221                 m_fragmentSrc = tcu::StringTemplate(fragmentTmpl).specialize(fragmentParams);
1222         }
1223
1224         // Texture size matches viewport and nearest sampling is used. Thus texture sampling
1225         // is equal to just interpolating the texture value range.
1226
1227         // Determine value range for texture.
1228
1229         switch (m_precision)
1230         {
1231                 case glu::PRECISION_HIGHP:
1232                         m_texValueMin = tcu::Vec4(-97.f, 0.2f, 71.f, 74.f);
1233                         m_texValueMax = tcu::Vec4(-13.2f, -77.f, 44.f, 76.f);
1234                         break;
1235
1236                 case glu::PRECISION_MEDIUMP:
1237                         m_texValueMin = tcu::Vec4(-37.0f, 47.f, -7.f, 0.0f);
1238                         m_texValueMax = tcu::Vec4(-1.0f, 12.f, 7.f, 19.f);
1239                         break;
1240
1241                 case glu::PRECISION_LOWP:
1242                         m_texValueMin = tcu::Vec4(0.0f, -1.0f, 0.0f, 1.0f);
1243                         m_texValueMax = tcu::Vec4(1.0f, 1.0f, -1.0f, -1.0f);
1244                         break;
1245
1246                 default:
1247                         DE_ASSERT(false);
1248         }
1249
1250         // Lowp and mediump cases use RGBA16F format, while highp uses RGBA32F.
1251         {
1252                 const tcu::IVec2 viewportSize = getViewportSize();
1253                 DE_ASSERT(!m_texture);
1254                 m_texture = new glu::Texture2D(m_context.getRenderContext(), m_precision == glu::PRECISION_HIGHP ? GL_RGBA32F : GL_RGBA16F, viewportSize.x(), viewportSize.y());
1255                 m_texture->getRefTexture().allocLevel(0);
1256         }
1257
1258         // Texture coordinates
1259         m_coordMin = tcu::Vec4(0.0f);
1260         m_coordMax = tcu::Vec4(1.0f);
1261
1262         // Fill with gradients.
1263         {
1264                 const tcu::PixelBufferAccess level0 = m_texture->getRefTexture().getLevel(0);
1265                 for (int y = 0; y < level0.getHeight(); y++)
1266                 {
1267                         for (int x = 0; x < level0.getWidth(); x++)
1268                         {
1269                                 const float             xf              = (float(x)+0.5f) / float(level0.getWidth());
1270                                 const float             yf              = (float(y)+0.5f) / float(level0.getHeight());
1271                                 const tcu::Vec4 s               = tcu::Vec4(xf, yf, (xf+yf)/2.0f, 1.0f - (xf+yf)/2.0f);
1272
1273                                 level0.setPixel(m_texValueMin + (m_texValueMax - m_texValueMin)*s, x, y);
1274                         }
1275                 }
1276         }
1277
1278         m_texture->upload();
1279
1280         if (m_surfaceType == SURFACETYPE_FLOAT_FBO)
1281         {
1282                 // No scale or bias used for accuracy.
1283                 m_derivScale    = tcu::Vec4(1.0f);
1284                 m_derivBias             = tcu::Vec4(0.0f);
1285         }
1286         else
1287         {
1288                 // Compute scale - bias that normalizes to 0..1 range.
1289                 const tcu::IVec2        viewportSize    = getViewportSize();
1290                 const float                     w                               = float(viewportSize.x());
1291                 const float                     h                               = float(viewportSize.y());
1292                 const tcu::Vec4         dx                              = (m_texValueMax - m_texValueMin) / tcu::Vec4(w, w, w*0.5f, -w*0.5f);
1293                 const tcu::Vec4         dy                              = (m_texValueMax - m_texValueMin) / tcu::Vec4(h, h, h*0.5f, -h*0.5f);
1294
1295                 switch (m_func)
1296                 {
1297                         case DERIVATE_DFDX:
1298                                 m_derivScale = 0.5f / dx;
1299                                 break;
1300
1301                         case DERIVATE_DFDY:
1302                                 m_derivScale = 0.5f / dy;
1303                                 break;
1304
1305                         case DERIVATE_FWIDTH:
1306                                 m_derivScale = 0.5f / (tcu::abs(dx) + tcu::abs(dy));
1307                                 break;
1308
1309                         default:
1310                                 DE_ASSERT(false);
1311                 }
1312
1313                 m_derivBias = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
1314         }
1315 }
1316
1317 void TextureDerivateCase::deinit (void)
1318 {
1319         delete m_texture;
1320         m_texture = DE_NULL;
1321 }
1322
1323 void TextureDerivateCase::setupRenderState (deUint32 program)
1324 {
1325         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1326         const int                               texUnit         = 1;
1327
1328         gl.activeTexture        (GL_TEXTURE0+texUnit);
1329         gl.bindTexture          (GL_TEXTURE_2D, m_texture->getGLTexture());
1330         gl.texParameteri        (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
1331         gl.texParameteri        (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
1332         gl.texParameteri        (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
1333         gl.texParameteri        (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
1334
1335         gl.uniform1i            (gl.getUniformLocation(program, "u_sampler"), texUnit);
1336 }
1337
1338 bool TextureDerivateCase::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
1339 {
1340         // \note Edges are ignored in comparison
1341         if (result.getWidth() < 2 || result.getHeight() < 2)
1342                 throw tcu::NotSupportedError("Too small viewport");
1343
1344         tcu::ConstPixelBufferAccess     compareArea                     = tcu::getSubregion(result, 1, 1, result.getWidth()-2, result.getHeight()-2);
1345         tcu::PixelBufferAccess          maskArea                        = tcu::getSubregion(errorMask, 1, 1, errorMask.getWidth()-2, errorMask.getHeight()-2);
1346         const tcu::Vec4                         xScale                          = tcu::Vec4(1.0f, 0.0f, 0.5f, -0.5f);
1347         const tcu::Vec4                         yScale                          = tcu::Vec4(0.0f, 1.0f, 0.5f, -0.5f);
1348         const float                                     w                                       = float(result.getWidth());
1349         const float                                     h                                       = float(result.getHeight());
1350
1351         const tcu::Vec4                         surfaceThreshold        = getSurfaceThreshold() / abs(m_derivScale);
1352
1353         if (m_func == DERIVATE_DFDX || m_func == DERIVATE_DFDY)
1354         {
1355                 const bool                      isX                     = m_func == DERIVATE_DFDX;
1356                 const float                     div                     = isX ? w : h;
1357                 const tcu::Vec4         scale           = isX ? xScale : yScale;
1358                 const tcu::Vec4         reference       = ((m_texValueMax - m_texValueMin) / div) * scale;
1359                 const tcu::Vec4         opThreshold     = getDerivateThreshold(m_precision, m_texValueMin*scale, m_texValueMax*scale, reference);
1360                 const tcu::Vec4         threshold       = max(surfaceThreshold, opThreshold);
1361                 const int                       numComps        = glu::getDataTypeFloatScalars(m_dataType);
1362
1363                 m_testCtx.getLog()
1364                         << tcu::TestLog::Message
1365                         << "Verifying result image.\n"
1366                         << "\tValid derivative is " << LogVecComps(reference, numComps) << " with threshold " << LogVecComps(threshold, numComps)
1367                         << tcu::TestLog::EndMessage;
1368
1369                 // short circuit if result is strictly within the normal value error bounds.
1370                 // This improves performance significantly.
1371                 if (verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType,
1372                                                                    reference, threshold, m_derivScale, m_derivBias,
1373                                                                    LOG_NOTHING))
1374                 {
1375                         m_testCtx.getLog()
1376                                 << tcu::TestLog::Message
1377                                 << "No incorrect derivatives found, result valid."
1378                                 << tcu::TestLog::EndMessage;
1379
1380                         return true;
1381                 }
1382
1383                 // some pixels exceed error bounds calculated for normal values. Verify that these
1384                 // potentially invalid pixels are in fact valid due to (for example) subnorm flushing.
1385
1386                 m_testCtx.getLog()
1387                         << tcu::TestLog::Message
1388                         << "Initial verification failed, verifying image by calculating accurate error bounds for each result pixel.\n"
1389                         << "\tVerifying each result derivative is within its range of legal result values."
1390                         << tcu::TestLog::EndMessage;
1391
1392                 {
1393                         const tcu::Vec4                         valueRamp               = (m_texValueMax - m_texValueMin);
1394                         Linear2DFunctionEvaluator       function;
1395
1396                         function.matrix.setRow(0, tcu::Vec3(valueRamp.x() / w, 0.0f, m_texValueMin.x()));
1397                         function.matrix.setRow(1, tcu::Vec3(0.0f, valueRamp.y() / h, m_texValueMin.y()));
1398                         function.matrix.setRow(2, tcu::Vec3(valueRamp.z() / w, valueRamp.z() / h, m_texValueMin.z() + m_texValueMin.z()) / 2.0f);
1399                         function.matrix.setRow(3, tcu::Vec3(-valueRamp.w() / w, -valueRamp.w() / h, m_texValueMax.w() + m_texValueMax.w()) / 2.0f);
1400
1401                         return reverifyConstantDerivateWithFlushRelaxations(m_testCtx.getLog(), compareArea, maskArea,
1402                                                                                                                                 m_dataType, m_precision, m_derivScale,
1403                                                                                                                                 m_derivBias, surfaceThreshold, m_func,
1404                                                                                                                                 function);
1405                 }
1406         }
1407         else
1408         {
1409                 DE_ASSERT(m_func == DERIVATE_FWIDTH);
1410                 const tcu::Vec4 dx                      = ((m_texValueMax - m_texValueMin) / w) * xScale;
1411                 const tcu::Vec4 dy                      = ((m_texValueMax - m_texValueMin) / h) * yScale;
1412                 const tcu::Vec4 reference       = tcu::abs(dx) + tcu::abs(dy);
1413                 const tcu::Vec4 dxThreshold     = getDerivateThreshold(m_precision, m_texValueMin*xScale, m_texValueMax*xScale, dx);
1414                 const tcu::Vec4 dyThreshold     = getDerivateThreshold(m_precision, m_texValueMin*yScale, m_texValueMax*yScale, dy);
1415                 const tcu::Vec4 threshold       = max(surfaceThreshold, max(dxThreshold, dyThreshold));
1416
1417                 return verifyConstantDerivate(m_testCtx.getLog(), compareArea, maskArea, m_dataType,
1418                                                                           reference, threshold, m_derivScale, m_derivBias);
1419         }
1420 }
1421
1422 ShaderDerivateTests::ShaderDerivateTests (Context& context)
1423         : TestCaseGroup(context, "derivate", "Derivate Function Tests")
1424 {
1425 }
1426
1427 ShaderDerivateTests::~ShaderDerivateTests (void)
1428 {
1429 }
1430
1431 struct FunctionSpec
1432 {
1433         std::string             name;
1434         DerivateFunc    function;
1435         glu::DataType   dataType;
1436         glu::Precision  precision;
1437
1438         FunctionSpec (const std::string& name_, DerivateFunc function_, glu::DataType dataType_, glu::Precision precision_)
1439                 : name          (name_)
1440                 , function      (function_)
1441                 , dataType      (dataType_)
1442                 , precision     (precision_)
1443         {
1444         }
1445 };
1446
1447 void ShaderDerivateTests::init (void)
1448 {
1449         static const struct
1450         {
1451                 const char*             name;
1452                 const char*             description;
1453                 const char*             source;
1454         } s_linearDerivateCases[] =
1455         {
1456                 {
1457                         "linear",
1458                         "Basic derivate of linearly interpolated argument",
1459
1460                         "#version 300 es\n"
1461                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1462                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1463                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1464                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1465                         "void main (void)\n"
1466                         "{\n"
1467                         "       ${PRECISION} ${DATATYPE} res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
1468                         "       o_color = ${CAST_TO_OUTPUT};\n"
1469                         "}\n"
1470                 },
1471                 {
1472                         "in_function",
1473                         "Derivate of linear function argument",
1474
1475                         "#version 300 es\n"
1476                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1477                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1478                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1479                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1480                         "\n"
1481                         "${PRECISION} ${DATATYPE} computeRes (${PRECISION} ${DATATYPE} value)\n"
1482                         "{\n"
1483                         "       return ${FUNC}(v_coord) * u_scale + u_bias;\n"
1484                         "}\n"
1485                         "\n"
1486                         "void main (void)\n"
1487                         "{\n"
1488                         "       ${PRECISION} ${DATATYPE} res = computeRes(v_coord);\n"
1489                         "       o_color = ${CAST_TO_OUTPUT};\n"
1490                         "}\n"
1491                 },
1492                 {
1493                         "static_if",
1494                         "Derivate of linearly interpolated value in static if",
1495
1496                         "#version 300 es\n"
1497                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1498                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1499                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1500                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1501                         "void main (void)\n"
1502                         "{\n"
1503                         "       ${PRECISION} ${DATATYPE} res;\n"
1504                         "       if (false)\n"
1505                         "               res = ${FUNC}(-v_coord) * u_scale + u_bias;\n"
1506                         "       else\n"
1507                         "               res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
1508                         "       o_color = ${CAST_TO_OUTPUT};\n"
1509                         "}\n"
1510                 },
1511                 {
1512                         "static_loop",
1513                         "Derivate of linearly interpolated value in static loop",
1514
1515                         "#version 300 es\n"
1516                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1517                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1518                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1519                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1520                         "void main (void)\n"
1521                         "{\n"
1522                         "       ${PRECISION} ${DATATYPE} res = ${DATATYPE}(0.0);\n"
1523                         "       for (int i = 0; i < 2; i++)\n"
1524                         "               res += ${FUNC}(v_coord * float(i));\n"
1525                         "       res = res * u_scale + u_bias;\n"
1526                         "       o_color = ${CAST_TO_OUTPUT};\n"
1527                         "}\n"
1528                 },
1529                 {
1530                         "static_switch",
1531                         "Derivate of linearly interpolated value in static switch",
1532
1533                         "#version 300 es\n"
1534                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1535                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1536                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1537                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1538                         "void main (void)\n"
1539                         "{\n"
1540                         "       ${PRECISION} ${DATATYPE} res;\n"
1541                         "       switch (1)\n"
1542                         "       {\n"
1543                         "               case 0: res = ${FUNC}(-v_coord) * u_scale + u_bias;     break;\n"
1544                         "               case 1: res = ${FUNC}(v_coord) * u_scale + u_bias;      break;\n"
1545                         "       }\n"
1546                         "       o_color = ${CAST_TO_OUTPUT};\n"
1547                         "}\n"
1548                 },
1549                 {
1550                         "uniform_if",
1551                         "Derivate of linearly interpolated value in uniform if",
1552
1553                         "#version 300 es\n"
1554                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1555                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1556                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1557                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1558                         "uniform bool ub_true;\n"
1559                         "void main (void)\n"
1560                         "{\n"
1561                         "       ${PRECISION} ${DATATYPE} res;\n"
1562                         "       if (ub_true)"
1563                         "               res = ${FUNC}(v_coord) * u_scale + u_bias;\n"
1564                         "       else\n"
1565                         "               res = ${FUNC}(-v_coord) * u_scale + u_bias;\n"
1566                         "       o_color = ${CAST_TO_OUTPUT};\n"
1567                         "}\n"
1568                 },
1569                 {
1570                         "uniform_loop",
1571                         "Derivate of linearly interpolated value in uniform loop",
1572
1573                         "#version 300 es\n"
1574                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1575                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1576                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1577                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1578                         "uniform int ui_two;\n"
1579                         "void main (void)\n"
1580                         "{\n"
1581                         "       ${PRECISION} ${DATATYPE} res = ${DATATYPE}(0.0);\n"
1582                         "       for (int i = 0; i < ui_two; i++)\n"
1583                         "               res += ${FUNC}(v_coord * float(i));\n"
1584                         "       res = res * u_scale + u_bias;\n"
1585                         "       o_color = ${CAST_TO_OUTPUT};\n"
1586                         "}\n"
1587                 },
1588                 {
1589                         "uniform_switch",
1590                         "Derivate of linearly interpolated value in uniform switch",
1591
1592                         "#version 300 es\n"
1593                         "in ${PRECISION} ${DATATYPE} v_coord;\n"
1594                         "layout(location = 0) out ${OUTPUT_PREC} ${OUTPUT_TYPE} o_color;\n"
1595                         "uniform ${PRECISION} ${DATATYPE} u_scale;\n"
1596                         "uniform ${PRECISION} ${DATATYPE} u_bias;\n"
1597                         "uniform int ui_one;\n"
1598                         "void main (void)\n"
1599                         "{\n"
1600                         "       ${PRECISION} ${DATATYPE} res;\n"
1601                         "       switch (ui_one)\n"
1602                         "       {\n"
1603                         "               case 0: res = ${FUNC}(-v_coord) * u_scale + u_bias;     break;\n"
1604                         "               case 1: res = ${FUNC}(v_coord) * u_scale + u_bias;      break;\n"
1605                         "       }\n"
1606                         "       o_color = ${CAST_TO_OUTPUT};\n"
1607                         "}\n"
1608                 },
1609         };
1610
1611         static const struct
1612         {
1613                 const char*             name;
1614                 SurfaceType             surfaceType;
1615                 int                             numSamples;
1616         } s_fboConfigs[] =
1617         {
1618                 { "fbo",                SURFACETYPE_DEFAULT_FRAMEBUFFER,        0 },
1619                 { "fbo_msaa2",  SURFACETYPE_UNORM_FBO,                          2 },
1620                 { "fbo_msaa4",  SURFACETYPE_UNORM_FBO,                          4 },
1621                 { "fbo_float",  SURFACETYPE_FLOAT_FBO,                          0 },
1622         };
1623
1624         static const struct
1625         {
1626                 const char*             name;
1627                 deUint32                hint;
1628         } s_hints[] =
1629         {
1630                 { "fastest",    GL_FASTEST      },
1631                 { "nicest",             GL_NICEST       },
1632         };
1633
1634         static const struct
1635         {
1636                 const char*             name;
1637                 SurfaceType             surfaceType;
1638                 int                             numSamples;
1639         } s_hintFboConfigs[] =
1640         {
1641                 { "default",            SURFACETYPE_DEFAULT_FRAMEBUFFER,        0 },
1642                 { "fbo_msaa4",          SURFACETYPE_UNORM_FBO,                          4 },
1643                 { "fbo_float",          SURFACETYPE_FLOAT_FBO,                          0 }
1644         };
1645
1646         static const struct
1647         {
1648                 const char*             name;
1649                 SurfaceType             surfaceType;
1650                 int                             numSamples;
1651                 deUint32                hint;
1652         } s_textureConfigs[] =
1653         {
1654                 { "basic",                      SURFACETYPE_DEFAULT_FRAMEBUFFER,        0,      GL_DONT_CARE    },
1655                 { "msaa4",                      SURFACETYPE_UNORM_FBO,                          4,      GL_DONT_CARE    },
1656                 { "float_fastest",      SURFACETYPE_FLOAT_FBO,                          0,      GL_FASTEST              },
1657                 { "float_nicest",       SURFACETYPE_FLOAT_FBO,                          0,      GL_NICEST               },
1658         };
1659
1660         // .dfdx, .dfdy, .fwidth
1661         for (int funcNdx = 0; funcNdx < DERIVATE_LAST; funcNdx++)
1662         {
1663                 const DerivateFunc                      function                = DerivateFunc(funcNdx);
1664                 tcu::TestCaseGroup* const       functionGroup   = new tcu::TestCaseGroup(m_testCtx, getDerivateFuncCaseName(function), getDerivateFuncName(function));
1665                 addChild(functionGroup);
1666
1667                 // .constant - no precision variants, checks that derivate of constant arguments is 0
1668                 {
1669                         tcu::TestCaseGroup* const constantGroup = new tcu::TestCaseGroup(m_testCtx, "constant", "Derivate of constant argument");
1670                         functionGroup->addChild(constantGroup);
1671
1672                         for (int vecSize = 1; vecSize <= 4; vecSize++)
1673                         {
1674                                 const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1675                                 constantGroup->addChild(new ConstantDerivateCase(m_context, glu::getDataTypeName(dataType), "", function, dataType));
1676                         }
1677                 }
1678
1679                 // Cases based on LinearDerivateCase
1680                 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(s_linearDerivateCases); caseNdx++)
1681                 {
1682                         tcu::TestCaseGroup* const linearCaseGroup       = new tcu::TestCaseGroup(m_testCtx, s_linearDerivateCases[caseNdx].name, s_linearDerivateCases[caseNdx].description);
1683                         const char*                     source                                  = s_linearDerivateCases[caseNdx].source;
1684                         functionGroup->addChild(linearCaseGroup);
1685
1686                         for (int vecSize = 1; vecSize <= 4; vecSize++)
1687                         {
1688                                 for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
1689                                 {
1690                                         const glu::DataType             dataType                = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1691                                         const glu::Precision    precision               = glu::Precision(precNdx);
1692                                         const SurfaceType               surfaceType             = SURFACETYPE_DEFAULT_FRAMEBUFFER;
1693                                         const int                               numSamples              = 0;
1694                                         const deUint32                  hint                    = GL_DONT_CARE;
1695                                         ostringstream                   caseName;
1696
1697                                         if (caseNdx != 0 && precision == glu::PRECISION_LOWP)
1698                                                 continue; // Skip as lowp doesn't actually produce any bits when rendered to default FB.
1699
1700                                         caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);
1701
1702                                         linearCaseGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function, dataType, precision, hint, surfaceType, numSamples, source));
1703                                 }
1704                         }
1705                 }
1706
1707                 // Fbo cases
1708                 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(s_fboConfigs); caseNdx++)
1709                 {
1710                         tcu::TestCaseGroup*     const   fboGroup                = new tcu::TestCaseGroup(m_testCtx, s_fboConfigs[caseNdx].name, "Derivate usage when rendering into FBO");
1711                         const char*                                     source                  = s_linearDerivateCases[0].source; // use source from .linear group
1712                         const SurfaceType                       surfaceType             = s_fboConfigs[caseNdx].surfaceType;
1713                         const int                                       numSamples              = s_fboConfigs[caseNdx].numSamples;
1714                         functionGroup->addChild(fboGroup);
1715
1716                         for (int vecSize = 1; vecSize <= 4; vecSize++)
1717                         {
1718                                 for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
1719                                 {
1720                                         const glu::DataType             dataType                = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1721                                         const glu::Precision    precision               = glu::Precision(precNdx);
1722                                         const deUint32                  hint                    = GL_DONT_CARE;
1723                                         ostringstream                   caseName;
1724
1725                                         if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
1726                                                 continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.
1727
1728                                         caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);
1729
1730                                         fboGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function, dataType, precision, hint, surfaceType, numSamples, source));
1731                                 }
1732                         }
1733                 }
1734
1735                 // .fastest, .nicest
1736                 for (int hintCaseNdx = 0; hintCaseNdx < DE_LENGTH_OF_ARRAY(s_hints); hintCaseNdx++)
1737                 {
1738                         tcu::TestCaseGroup* const       hintGroup               = new tcu::TestCaseGroup(m_testCtx, s_hints[hintCaseNdx].name, "Shader derivate hints");
1739                         const char*                                     source                  = s_linearDerivateCases[0].source; // use source from .linear group
1740                         const deUint32                          hint                    = s_hints[hintCaseNdx].hint;
1741                         functionGroup->addChild(hintGroup);
1742
1743                         for (int fboCaseNdx = 0; fboCaseNdx < DE_LENGTH_OF_ARRAY(s_hintFboConfigs); fboCaseNdx++)
1744                         {
1745                                 tcu::TestCaseGroup*     const   fboGroup                = new tcu::TestCaseGroup(m_testCtx, s_hintFboConfigs[fboCaseNdx].name, "");
1746                                 const SurfaceType                       surfaceType             = s_hintFboConfigs[fboCaseNdx].surfaceType;
1747                                 const int                                       numSamples              = s_hintFboConfigs[fboCaseNdx].numSamples;
1748                                 hintGroup->addChild(fboGroup);
1749
1750                                 for (int vecSize = 1; vecSize <= 4; vecSize++)
1751                                 {
1752                                         for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
1753                                         {
1754                                                 const glu::DataType             dataType                = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1755                                                 const glu::Precision    precision               = glu::Precision(precNdx);
1756                                                 ostringstream                   caseName;
1757
1758                                                 if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
1759                                                         continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.
1760
1761                                                 caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);
1762
1763                                                 fboGroup->addChild(new LinearDerivateCase(m_context, caseName.str().c_str(), "", function, dataType, precision, hint, surfaceType, numSamples, source));
1764                                         }
1765                                 }
1766                         }
1767                 }
1768
1769                 // .texture
1770                 {
1771                         tcu::TestCaseGroup* const textureGroup = new tcu::TestCaseGroup(m_testCtx, "texture", "Derivate of texture lookup result");
1772                         functionGroup->addChild(textureGroup);
1773
1774                         for (int texCaseNdx = 0; texCaseNdx < DE_LENGTH_OF_ARRAY(s_textureConfigs); texCaseNdx++)
1775                         {
1776                                 tcu::TestCaseGroup*     const   caseGroup               = new tcu::TestCaseGroup(m_testCtx, s_textureConfigs[texCaseNdx].name, "");
1777                                 const SurfaceType                       surfaceType             = s_textureConfigs[texCaseNdx].surfaceType;
1778                                 const int                                       numSamples              = s_textureConfigs[texCaseNdx].numSamples;
1779                                 const deUint32                          hint                    = s_textureConfigs[texCaseNdx].hint;
1780                                 textureGroup->addChild(caseGroup);
1781
1782                                 for (int vecSize = 1; vecSize <= 4; vecSize++)
1783                                 {
1784                                         for (int precNdx = 0; precNdx < glu::PRECISION_LAST; precNdx++)
1785                                         {
1786                                                 const glu::DataType             dataType                = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1787                                                 const glu::Precision    precision               = glu::Precision(precNdx);
1788                                                 ostringstream                   caseName;
1789
1790                                                 if (surfaceType != SURFACETYPE_FLOAT_FBO && precision == glu::PRECISION_LOWP)
1791                                                         continue; // Skip as lowp doesn't actually produce any bits when rendered to U8 RT.
1792
1793                                                 caseName << glu::getDataTypeName(dataType) << "_" << glu::getPrecisionName(precision);
1794
1795                                                 caseGroup->addChild(new TextureDerivateCase(m_context, caseName.str().c_str(), "", function, dataType, precision, hint, surfaceType, numSamples));
1796                                         }
1797                                 }
1798                         }
1799                 }
1800         }
1801 }
1802
1803 } // Functional
1804 } // gles3
1805 } // deqp