modules/gles3/functional/es3fShaderPrecisionTests.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 precision tests.
  22  *
  23  * \note Floating-point case uses R32UI render target and uses
  24  *               floatBitsToUint() in shader to write out floating-point value bits.
  25  *               This is done since ES3 core doesn't support FP render targets.
  26  *//*--------------------------------------------------------------------*/
  27
  28 #include "es3fShaderPrecisionTests.hpp"
  29 #include "tcuVector.hpp"
  30 #include "tcuTestLog.hpp"
  31 #include "tcuVectorUtil.hpp"
  32 #include "tcuFloat.hpp"
  33 #include "tcuFormatUtil.hpp"
  34 #include "gluRenderContext.hpp"
  35 #include "gluShaderProgram.hpp"
  36 #include "gluShaderUtil.hpp"
  37 #include "gluDrawUtil.hpp"
  38 #include "deRandom.hpp"
  39 #include "deString.h"
  40
  41 #include "glwEnums.hpp"
  42 #include "glwFunctions.hpp"
  43
  44 #include <algorithm>
  45
  46 namespace deqp
  47 {
  48 namespace gles3
  49 {
  50 namespace Functional
  51 {
  52
  53 using std::string;
  54 using std::vector;
  55 using std::ostringstream;
  56 using tcu::TestLog;
  57
  58 enum
  59 {
  60         FRAMEBUFFER_WIDTH       = 32,
  61         FRAMEBUFFER_HEIGHT      = 32
  62 };
  63
  64 static glu::ShaderProgram* createFloatPrecisionEvalProgram (const glu::RenderContext& context, glu::Precision precision, const char* evalOp, bool isVertexCase)
  65 {
  66         glu::DataType   type            = glu::TYPE_FLOAT;
  67         glu::DataType   outType         = glu::TYPE_UINT;
  68         const char*             typeName        = glu::getDataTypeName(type);
  69         const char*             outTypeName     = glu::getDataTypeName(outType);
  70         const char*             precName        = glu::getPrecisionName(precision);
  71         ostringstream   vtx;
  72         ostringstream   frag;
  73         ostringstream&  op                      = isVertexCase ? vtx : frag;
  74
  75         vtx << "#version 300 es\n"
  76                 << "in highp vec4 a_position;\n"
  77                 << "in " << precName << " " << typeName << " a_in0;\n"
  78                 << "in " << precName << " " << typeName << " a_in1;\n";
  79         frag << "#version 300 es\n"
  80                  << "layout(location = 0) out highp " << outTypeName << " o_out;\n";
  81
  82         if (isVertexCase)
  83         {
  84                 vtx << "flat out " << precName << " " << typeName << " v_out;\n";
  85                 frag << "flat in " << precName << " " << typeName << " v_out;\n";
  86         }
  87         else
  88         {
  89                 vtx << "flat out " << precName << " " << typeName << " v_in0;\n"
  90                         << "flat out " << precName << " " << typeName << " v_in1;\n";
  91                 frag << "flat in " << precName << " " << typeName << " v_in0;\n"
  92                          << "flat in " << precName << " " << typeName << " v_in1;\n";
  93         }
  94
  95         vtx << "\nvoid main (void)\n{\n"
  96                 << "    gl_Position = a_position;\n";
  97         frag << "\nvoid main (void)\n{\n";
  98
  99         op << "\t" << precName << " " << typeName << " in0 = " << (isVertexCase ? "a_" : "v_") << "in0;\n"
 100            << "\t" << precName << " " << typeName << " in1 = " << (isVertexCase ? "a_" : "v_") << "in1;\n";
 101
 102         if (!isVertexCase)
 103                 op << "\t" << precName << " " << typeName << " res;\n";
 104
 105         op << "\t" << (isVertexCase ? "v_out" : "res") << " = " << evalOp << ";\n";
 106
 107         if (isVertexCase)
 108         {
 109                 frag << "       o_out = floatBitsToUint(v_out);\n";
 110         }
 111         else
 112         {
 113                 vtx << "        v_in0 = a_in0;\n"
 114                         << "    v_in1 = a_in1;\n";
 115                 frag << "       o_out = floatBitsToUint(res);\n";
 116         }
 117
 118         vtx << "}\n";
 119         frag << "}\n";
 120
 121         return new glu::ShaderProgram(context, glu::makeVtxFragSources(vtx.str(), frag.str()));
 122 }
 123
 124 static glu::ShaderProgram* createIntUintPrecisionEvalProgram (const glu::RenderContext& context, glu::DataType type, glu::Precision precision, const char* evalOp, bool isVertexCase)
 125 {
 126         const char*             typeName        = glu::getDataTypeName(type);
 127         const char*             precName        = glu::getPrecisionName(precision);
 128         ostringstream   vtx;
 129         ostringstream   frag;
 130         ostringstream&  op                      = isVertexCase ? vtx : frag;
 131
 132         vtx << "#version 300 es\n"
 133                 << "in highp vec4 a_position;\n"
 134                 << "in " << precName << " " << typeName << " a_in0;\n"
 135                 << "in " << precName << " " << typeName << " a_in1;\n";
 136         frag << "#version 300 es\n"
 137                  << "layout(location = 0) out " << precName << " " << typeName << " o_out;\n";
 138
 139         if (isVertexCase)
 140         {
 141                 vtx << "flat out " << precName << " " << typeName << " v_out;\n";
 142                 frag << "flat in " << precName << " " << typeName << " v_out;\n";
 143         }
 144         else
 145         {
 146                 vtx << "flat out " << precName << " " << typeName << " v_in0;\n"
 147                         << "flat out " << precName << " " << typeName << " v_in1;\n";
 148                 frag << "flat in " << precName << " " << typeName << " v_in0;\n"
 149                          << "flat in " << precName << " " << typeName << " v_in1;\n";
 150         }
 151
 152         vtx << "\nvoid main (void)\n{\n"
 153                 << "    gl_Position = a_position;\n";
 154         frag << "\nvoid main (void)\n{\n";
 155
 156         op << "\t" << precName << " " << typeName << " in0 = " << (isVertexCase ? "a_" : "v_") << "in0;\n"
 157            << "\t" << precName << " " << typeName << " in1 = " << (isVertexCase ? "a_" : "v_") << "in1;\n";
 158
 159         op << "\t" << (isVertexCase ? "v_" : "o_") << "out = " << evalOp << ";\n";
 160
 161         if (isVertexCase)
 162         {
 163                 frag << "       o_out = v_out;\n";
 164         }
 165         else
 166         {
 167                 vtx << "        v_in0 = a_in0;\n"
 168                         << "    v_in1 = a_in1;\n";
 169         }
 170
 171         vtx << "}\n";
 172         frag << "}\n";
 173
 174         return new glu::ShaderProgram(context, glu::makeVtxFragSources(vtx.str(), frag.str()));
 175 }
 176
 177 class ShaderFloatPrecisionCase : public TestCase
 178 {
 179 public:
 180         typedef double (*EvalFunc) (double in0, double in1);
 181
 182                                                                 ShaderFloatPrecisionCase        (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, const tcu::Vec2& rangeA, const tcu::Vec2& rangeB, bool isVertexCase);
 183                                                                 ~ShaderFloatPrecisionCase       (void);
 184
 185         void                                            init                                            (void);
 186         void                                            deinit                                          (void);
 187         IterateResult                           iterate                                         (void);
 188
 189 protected:
 190         bool                                            compare                                         (float in0, float in1, double reference, float result)
 191 #if (DE_COMPILER == DE_COMPILER_GCC) && (DE_CPU == DE_CPU_ARM_64)
 192 #       if (__GNUC__ == 4) && (__GNUC_MINOR__ == 9) && (__GNUC_PATCHLEVEL__ == 0)
 193                 // Some prerelease GCC 4.9 versions have a bug in shift right when
 194                 // targeting ARMv8.
 195                 //
 196                 // If compiler wants to perform logical shift by variable/register
 197                 // in fp/vector registers it uses USHL that selects shift direction
 198                 // based on shift operand value. Thus for right shifts the shift
 199                 // operand needs to be negated.
 200                 //
 201                 // The bug is in right shift pattern; it doesn't mark shift operand
 202                 // as clobbered and thus later code using that same register may
 203                 // see the negated value.
 204                 //
 205                 // Workaround is to disable optimization for this function.
 206                 //
 207                 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61633
 208                 __attribute__((optimize(0)))
 209 #       endif
 210 #endif
 211         ;
 212
 213 private:
 214                                                                 ShaderFloatPrecisionCase        (const ShaderFloatPrecisionCase& other);
 215         ShaderFloatPrecisionCase&       operator=                                       (const ShaderFloatPrecisionCase& other);
 216
 217         // Case parameters.
 218         std::string                                     m_op;
 219         EvalFunc                                        m_evalFunc;
 220         glu::Precision                          m_precision;
 221         tcu::Vec2                                       m_rangeA;
 222         tcu::Vec2                                       m_rangeB;
 223         bool                                            m_isVertexCase;
 224
 225         int                                                     m_numTestsPerIter;
 226         int                                                     m_numIters;
 227         de::Random                                      m_rnd;
 228
 229         // Iteration state.
 230         glu::ShaderProgram*                     m_program;
 231         deUint32                                        m_framebuffer;
 232         deUint32                                        m_renderbuffer;
 233         int                                                     m_iterNdx;
 234 };
 235
 236 ShaderFloatPrecisionCase::ShaderFloatPrecisionCase (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, const tcu::Vec2& rangeA, const tcu::Vec2& rangeB, bool isVertexCase)
 237         : TestCase                      (context, name, desc)
 238         , m_op                          (op)
 239         , m_evalFunc            (evalFunc)
 240         , m_precision           (precision)
 241         , m_rangeA                      (rangeA)
 242         , m_rangeB                      (rangeB)
 243         , m_isVertexCase        (isVertexCase)
 244         , m_numTestsPerIter     (32)
 245         , m_numIters            (4)
 246         , m_rnd                         (deStringHash(name))
 247         , m_program                     (DE_NULL)
 248         , m_framebuffer         (0)
 249         , m_renderbuffer        (0)
 250         , m_iterNdx                     (0)
 251 {
 252 }
 253
 254 ShaderFloatPrecisionCase::~ShaderFloatPrecisionCase (void)
 255 {
 256         ShaderFloatPrecisionCase::deinit();
 257 }
 258
 259 void ShaderFloatPrecisionCase::init (void)
 260 {
 261         const glw::Functions&   gl      = m_context.getRenderContext().getFunctions();
 262         TestLog&                                log     = m_testCtx.getLog();
 263
 264         DE_ASSERT(!m_program && !m_framebuffer && !m_renderbuffer);
 265
 266         // Create program.
 267         m_program = createFloatPrecisionEvalProgram(m_context.getRenderContext(), m_precision, m_op.c_str(), m_isVertexCase);
 268         log << *m_program;
 269
 270         TCU_CHECK(m_program->isOk());
 271
 272         // Create framebuffer.
 273         gl.genFramebuffers(1, &m_framebuffer);
 274         gl.genRenderbuffers(1, &m_renderbuffer);
 275
 276         gl.bindRenderbuffer(GL_RENDERBUFFER, m_renderbuffer);
 277         gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT);
 278
 279         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 280         gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_renderbuffer);
 281
 282         GLU_EXPECT_NO_ERROR(gl.getError(), "Post framebuffer setup");
 283         TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 284
 285         gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer());
 286
 287         // Initialize test result to pass.
 288         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 289         m_iterNdx = 0;
 290 }
 291
 292 void ShaderFloatPrecisionCase::deinit (void)
 293 {
 294         delete m_program;
 295
 296         if (m_framebuffer)
 297                 m_context.getRenderContext().getFunctions().deleteFramebuffers(1, &m_framebuffer);
 298
 299         if (m_renderbuffer)
 300                 m_context.getRenderContext().getFunctions().deleteRenderbuffers(1, &m_renderbuffer);
 301
 302         m_program               = DE_NULL;
 303         m_framebuffer   = 0;
 304         m_renderbuffer  = 0;
 305 }
 306
 307 bool ShaderFloatPrecisionCase::compare (float in0, float in1, double reference, float result)
 308 {
 309         // Comparison is done using 64-bit reference value to accurately evaluate rounding mode error.
 310         // If 32-bit reference value is used, 2 bits of rounding error must be allowed.
 311
 312         // For mediump and lowp types the comparison currently allows 3 bits of rounding error:
 313         // two bits from conversions and one from actual operation.
 314
 315         // \todo [2013-09-30 pyry] Make this more strict: determine if rounding can actually happen.
 316
 317         const int               mantissaBits            = m_precision == glu::PRECISION_HIGHP ? 23 : 10;
 318         const int               numPrecBits                     = 52 - mantissaBits;
 319
 320         const int               in0Exp                          = tcu::Float32(in0).exponent();
 321         const int               in1Exp                          = tcu::Float32(in1).exponent();
 322         const int               resExp                          = tcu::Float32(result).exponent();
 323         const int               numLostBits                     = de::max(de::max(in0Exp-resExp, in1Exp-resExp), 0); // Lost due to mantissa shift.
 324
 325         const int               roundingUlpError        = m_precision == glu::PRECISION_HIGHP ? 1 : 3;
 326         const int               maskBits                        = numLostBits + numPrecBits;
 327
 328         m_testCtx.getLog() << TestLog::Message << "Assuming " << mantissaBits << " mantissa bits, " << numLostBits << " bits lost in operation, and " << roundingUlpError << " ULP rounding error."
 329                                            << TestLog::EndMessage;
 330
 331         {
 332                 const deUint64  refBits                         = tcu::Float64(reference).bits();
 333                 const deUint64  resBits                         = tcu::Float64(result).bits();
 334                 const deUint64  accurateRefBits         = maskBits < 64 ? refBits >> (deUint64)maskBits : 0u;
 335                 const deUint64  accurateResBits         = maskBits < 64 ? resBits >> (deUint64)maskBits : 0u;
 336                 const deUint64  ulpDiff                         = (deUint64)de::abs((deInt64)accurateRefBits - (deInt64)accurateResBits);
 337
 338                 if (ulpDiff > (deUint64)roundingUlpError)
 339                 {
 340                         m_testCtx.getLog() << TestLog::Message << "ERROR: comparison failed! ULP diff (ignoring lost/undefined bits) = " << ulpDiff << TestLog::EndMessage;
 341                         return false;
 342                 }
 343                 else
 344                         return true;
 345         }
 346 }
 347
 348 ShaderFloatPrecisionCase::IterateResult ShaderFloatPrecisionCase::iterate (void)
 349 {
 350         // Constant data.
 351         const float position[] =
 352         {
 353                 -1.0f, -1.0f, 0.0f, 1.0f,
 354                 -1.0f,  1.0f, 0.0f, 1.0f,
 355                  1.0f, -1.0f, 0.0f, 1.0f,
 356                  1.0f,  1.0f, 0.0f, 1.0f
 357         };
 358         const deUint16                                  indices[]       = { 0, 1, 2, 2, 1, 3 };
 359
 360         const int                                               numVertices     = 4;
 361         float                                                   in0Arr[4]       = { 0.0f };
 362         float                                                   in1Arr[4]       = { 0.0f };
 363
 364         TestLog&                                                log                     = m_testCtx.getLog();
 365         const glw::Functions&                   gl                      = m_context.getRenderContext().getFunctions();
 366         vector<glu::VertexArrayBinding> vertexArrays;
 367
 368         // Image read from GL.
 369         std::vector<float>      pixels          (FRAMEBUFFER_WIDTH*FRAMEBUFFER_HEIGHT*4);
 370
 371         // \todo [2012-05-03 pyry] Could be cached.
 372         deUint32                        prog            = m_program->getProgram();
 373
 374         gl.useProgram(prog);
 375         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 376
 377         vertexArrays.push_back(glu::va::Float("a_position", 4, numVertices, 0, &position[0]));
 378         vertexArrays.push_back(glu::va::Float("a_in0", 1, numVertices, 0, &in0Arr[0]));
 379         vertexArrays.push_back(glu::va::Float("a_in1", 1, numVertices, 0, &in1Arr[0]));
 380
 381         GLU_EXPECT_NO_ERROR(gl.getError(), "After program setup");
 382
 383         // Compute values and reference.
 384         for (int testNdx = 0; testNdx < m_numTestsPerIter; testNdx++)
 385         {
 386                 const float             in0             = m_rnd.getFloat(m_rangeA.x(), m_rangeA.y());
 387                 const float             in1             = m_rnd.getFloat(m_rangeB.x(), m_rangeB.y());
 388                 const double    refD    = m_evalFunc((double)in0, (double)in1);
 389                 const float             refF    = tcu::Float64(refD).asFloat(); // Uses RTE rounding mode.
 390
 391                 log << TestLog::Message << "iter " << m_iterNdx << ", test " << testNdx << ": "
 392                                                                 << "in0 = " << in0 << " / " << tcu::toHex(tcu::Float32(in0).bits())
 393                                                                 << ", in1 = " << in1 << " / " << tcu::toHex(tcu::Float32(in1).bits())
 394                         << TestLog::EndMessage
 395                         << TestLog::Message << "  reference = " << refF << " / " << tcu::toHex(tcu::Float32(refF).bits()) << TestLog::EndMessage;
 396
 397                 std::fill(&in0Arr[0], &in0Arr[0] + DE_LENGTH_OF_ARRAY(in0Arr), in0);
 398                 std::fill(&in1Arr[0], &in1Arr[0] + DE_LENGTH_OF_ARRAY(in1Arr), in1);
 399
 400                 glu::draw(m_context.getRenderContext(), prog, (int)vertexArrays.size(), &vertexArrays[0],
 401                                   glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
 402                 gl.readPixels(0, 0, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &pixels[0]);
 403                 GLU_EXPECT_NO_ERROR(gl.getError(), "After render");
 404
 405                 log << TestLog::Message << "  result = " << pixels[0] << " / " << tcu::toHex(tcu::Float32(pixels[0]).bits()) << TestLog::EndMessage;
 406
 407                 // Verify results
 408                 {
 409                         const bool firstPixelOk = compare(in0, in1, refD, pixels[0]);
 410
 411                         if (firstPixelOk)
 412                         {
 413                                 // Check that rest of pixels match to first one.
 414                                 const deUint32  firstPixelBits  = tcu::Float32(pixels[0]).bits();
 415                                 bool                    allPixelsOk             = true;
 416
 417                                 for (int y = 0; y < FRAMEBUFFER_HEIGHT; y++)
 418                                 {
 419                                         for (int x = 0; x < FRAMEBUFFER_WIDTH; x++)
 420                                         {
 421                                                 const deUint32 pixelBits = tcu::Float32(pixels[(y*FRAMEBUFFER_WIDTH + x)*4]).bits();
 422
 423                                                 if (pixelBits != firstPixelBits)
 424                                                 {
 425                                                         log << TestLog::Message << "ERROR: Inconsistent results, got " << tcu::toHex(pixelBits) << " at (" << x << ", " << y << ")" << TestLog::EndMessage;
 426                                                         allPixelsOk = false;
 427                                                 }
 428                                         }
 429
 430                                         if (!allPixelsOk)
 431                                                 break;
 432                                 }
 433
 434                                 if (!allPixelsOk)
 435                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Inconsistent values in framebuffer");
 436                         }
 437                         else
 438                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result comparison failed");
 439                 }
 440
 441                 if (m_testCtx.getTestResult() != QP_TEST_RESULT_PASS)
 442                         break;
 443         }
 444
 445         gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer());
 446         GLU_EXPECT_NO_ERROR(gl.getError(), "After iteration");
 447
 448         m_iterNdx += 1;
 449         return (m_iterNdx < m_numIters && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) ? CONTINUE : STOP;
 450 }
 451
 452 class ShaderIntPrecisionCase : public TestCase
 453 {
 454 public:
 455         typedef int                                     (*EvalFunc)                                     (int a, int b);
 456
 457                                                                 ShaderIntPrecisionCase          (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, int bits, const tcu::IVec2& rangeA, const tcu::IVec2& rangeB, bool isVertexCase);
 458                                                                 ~ShaderIntPrecisionCase         (void);
 459
 460         void                                            init                                            (void);
 461         void                                            deinit                                          (void);
 462         IterateResult                           iterate                                         (void);
 463
 464 private:
 465                                                                 ShaderIntPrecisionCase          (const ShaderIntPrecisionCase& other);
 466         ShaderIntPrecisionCase&         operator=                                       (const ShaderIntPrecisionCase& other);
 467
 468         // Case parameters.
 469         std::string                                     m_op;
 470         EvalFunc                                        m_evalFunc;
 471         glu::Precision                          m_precision;
 472         int                                                     m_bits;
 473         tcu::IVec2                                      m_rangeA;
 474         tcu::IVec2                                      m_rangeB;
 475         bool                                            m_isVertexCase;
 476
 477         int                                                     m_numTestsPerIter;
 478         int                                                     m_numIters;
 479         de::Random                                      m_rnd;
 480
 481         // Iteration state.
 482         glu::ShaderProgram*                     m_program;
 483         deUint32                                        m_framebuffer;
 484         deUint32                                        m_renderbuffer;
 485         int                                                     m_iterNdx;
 486 };
 487
 488 ShaderIntPrecisionCase::ShaderIntPrecisionCase (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, int bits, const tcu::IVec2& rangeA, const tcu::IVec2& rangeB, bool isVertexCase)
 489         : TestCase                      (context, name, desc)
 490         , m_op                          (op)
 491         , m_evalFunc            (evalFunc)
 492         , m_precision           (precision)
 493         , m_bits                        (bits)
 494         , m_rangeA                      (rangeA)
 495         , m_rangeB                      (rangeB)
 496         , m_isVertexCase        (isVertexCase)
 497         , m_numTestsPerIter     (32)
 498         , m_numIters            (4)
 499         , m_rnd                         (deStringHash(name))
 500         , m_program                     (DE_NULL)
 501         , m_framebuffer         (0)
 502         , m_renderbuffer        (0)
 503         , m_iterNdx                     (0)
 504 {
 505 }
 506
 507 ShaderIntPrecisionCase::~ShaderIntPrecisionCase (void)
 508 {
 509         ShaderIntPrecisionCase::deinit();
 510 }
 511
 512 void ShaderIntPrecisionCase::init (void)
 513 {
 514         const glw::Functions&   gl      = m_context.getRenderContext().getFunctions();
 515         TestLog&                                log     = m_testCtx.getLog();
 516
 517         DE_ASSERT(!m_program && !m_framebuffer && !m_renderbuffer);
 518
 519         // Create program.
 520         m_program = createIntUintPrecisionEvalProgram(m_context.getRenderContext(), glu::TYPE_INT, m_precision, m_op.c_str(), m_isVertexCase);
 521         log << *m_program;
 522
 523         TCU_CHECK(m_program->isOk());
 524
 525         // Create framebuffer.
 526         gl.genFramebuffers(1, &m_framebuffer);
 527         gl.genRenderbuffers(1, &m_renderbuffer);
 528
 529         gl.bindRenderbuffer(GL_RENDERBUFFER, m_renderbuffer);
 530         gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32I, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT);
 531
 532         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 533         gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_renderbuffer);
 534
 535         GLU_EXPECT_NO_ERROR(gl.getError(), "Post framebuffer setup");
 536         TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 537
 538         gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer());
 539
 540         // Initialize test result to pass.
 541         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 542         m_iterNdx = 0;
 543
 544         log << TestLog::Message << "Number of accurate bits assumed = " << m_bits << TestLog::EndMessage;
 545 }
 546
 547 void ShaderIntPrecisionCase::deinit (void)
 548 {
 549         delete m_program;
 550
 551         if (m_framebuffer)
 552                 m_context.getRenderContext().getFunctions().deleteFramebuffers(1, &m_framebuffer);
 553
 554         if (m_renderbuffer)
 555                 m_context.getRenderContext().getFunctions().deleteRenderbuffers(1, &m_renderbuffer);
 556
 557         m_program               = DE_NULL;
 558         m_framebuffer   = 0;
 559         m_renderbuffer  = 0;
 560 }
 561
 562 ShaderIntPrecisionCase::IterateResult ShaderIntPrecisionCase::iterate (void)
 563 {
 564         // Constant data.
 565         const float position[] =
 566         {
 567                 -1.0f, -1.0f, 0.0f, 1.0f,
 568                 -1.0f,  1.0f, 0.0f, 1.0f,
 569                  1.0f, -1.0f, 0.0f, 1.0f,
 570                  1.0f,  1.0f, 0.0f, 1.0f
 571         };
 572         const deUint16                                  indices[]       = { 0, 1, 2, 2, 1, 3 };
 573
 574         const int                                               numVertices     = 4;
 575         int                                                             in0Arr[4]       = { 0 };
 576         int                                                             in1Arr[4]       = { 0 };
 577
 578         TestLog&                                                log                     = m_testCtx.getLog();
 579         const glw::Functions&                   gl                      = m_context.getRenderContext().getFunctions();
 580         deUint32                                                mask            = m_bits == 32 ? 0xffffffffu : ((1u<<m_bits)-1);
 581         vector<int>                                             pixels          (FRAMEBUFFER_WIDTH*FRAMEBUFFER_HEIGHT*4);
 582         vector<glu::VertexArrayBinding> vertexArrays;
 583
 584         deUint32                                                prog            = m_program->getProgram();
 585
 586         // \todo [2012-05-03 pyry] A bit hacky. getInt() should work fine with ranges like this.
 587         bool                                                    isMaxRangeA     = m_rangeA.x() == (int)0x80000000 && m_rangeA.y() == (int)0x7fffffff;
 588         bool                                                    isMaxRangeB     = m_rangeB.x() == (int)0x80000000 && m_rangeB.y() == (int)0x7fffffff;
 589
 590         gl.useProgram(prog);
 591         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 592
 593         vertexArrays.push_back(glu::va::Float("a_position", 4, numVertices, 0, &position[0]));
 594         vertexArrays.push_back(glu::va::Int32("a_in0", 1, numVertices, 0, &in0Arr[0]));
 595         vertexArrays.push_back(glu::va::Int32("a_in1", 1, numVertices, 0, &in1Arr[0]));
 596
 597         GLU_EXPECT_NO_ERROR(gl.getError(), "After program setup");
 598
 599         // Compute values and reference.
 600         for (int testNdx = 0; testNdx < m_numTestsPerIter; testNdx++)
 601         {
 602                 int             in0                     = deSignExtendTo32(((isMaxRangeA ? (int)m_rnd.getUint32() : m_rnd.getInt(m_rangeA.x(), m_rangeA.y())) & mask), m_bits);
 603                 int             in1                     = deSignExtendTo32(((isMaxRangeB ? (int)m_rnd.getUint32() : m_rnd.getInt(m_rangeB.x(), m_rangeB.y())) & mask), m_bits);
 604                 int             refMasked       = m_evalFunc(in0, in1) & mask;
 605                 int             refOut          = deSignExtendTo32(refMasked, m_bits);
 606
 607                 log << TestLog::Message << "iter " << m_iterNdx << ", test " << testNdx << ": "
 608                                                                 << "in0 = " << in0 << ", in1 = " << in1 << ", ref out = " << refOut << " / " << tcu::toHex(refMasked)
 609                         << TestLog::EndMessage;
 610
 611                 std::fill(&in0Arr[0], &in0Arr[0] + DE_LENGTH_OF_ARRAY(in0Arr), in0);
 612                 std::fill(&in1Arr[0], &in1Arr[0] + DE_LENGTH_OF_ARRAY(in1Arr), in1);
 613
 614                 glu::draw(m_context.getRenderContext(), prog, (int)vertexArrays.size(), &vertexArrays[0],
 615                                   glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
 616                 gl.readPixels(0, 0, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, GL_RGBA_INTEGER, GL_INT, &pixels[0]);
 617                 GLU_EXPECT_NO_ERROR(gl.getError(), "After render");
 618
 619                 // Compare pixels.
 620                 for (int y = 0; y < FRAMEBUFFER_HEIGHT; y++)
 621                 {
 622                         for (int x = 0; x < FRAMEBUFFER_WIDTH; x++)
 623                         {
 624                                 int                     cmpOut          = pixels[(y*FRAMEBUFFER_WIDTH + x)*4];
 625                                 int                     cmpMasked       = cmpOut & mask;
 626
 627                                 if (cmpMasked != refMasked)
 628                                 {
 629                                         log << TestLog::Message << "Comparison failed (at " << x << ", " << y << "): "
 630                                                                                         << "got " << cmpOut << " / " << tcu::toHex(cmpOut)
 631                                                 << TestLog::EndMessage;
 632                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 633                                         return STOP;
 634                                 }
 635                         }
 636                 }
 637         }
 638
 639         gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer());
 640         GLU_EXPECT_NO_ERROR(gl.getError(), "After iteration");
 641
 642         m_iterNdx += 1;
 643         return (m_iterNdx < m_numIters) ? CONTINUE : STOP;
 644 }
 645
 646 class ShaderUintPrecisionCase : public TestCase
 647 {
 648 public:
 649         typedef deUint32                        (*EvalFunc)                                     (deUint32 a, deUint32 b);
 650
 651                                                                 ShaderUintPrecisionCase         (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, int bits, const tcu::UVec2& rangeA, const tcu::UVec2& rangeB, bool isVertexCase);
 652                                                                 ~ShaderUintPrecisionCase        (void);
 653
 654         void                                            init                                            (void);
 655         void                                            deinit                                          (void);
 656         IterateResult                           iterate                                         (void);
 657
 658 private:
 659                                                                 ShaderUintPrecisionCase         (const ShaderUintPrecisionCase& other);
 660         ShaderUintPrecisionCase&        operator=                                       (const ShaderUintPrecisionCase& other);
 661
 662         // Case parameters.
 663         std::string                                     m_op;
 664         EvalFunc                                        m_evalFunc;
 665         glu::Precision                          m_precision;
 666         int                                                     m_bits;
 667         tcu::UVec2                                      m_rangeA;
 668         tcu::UVec2                                      m_rangeB;
 669         bool                                            m_isVertexCase;
 670
 671         int                                                     m_numTestsPerIter;
 672         int                                                     m_numIters;
 673         de::Random                                      m_rnd;
 674
 675         // Iteration state.
 676         glu::ShaderProgram*                     m_program;
 677         deUint32                                        m_framebuffer;
 678         deUint32                                        m_renderbuffer;
 679         int                                                     m_iterNdx;
 680 };
 681
 682 ShaderUintPrecisionCase::ShaderUintPrecisionCase (Context& context, const char* name, const char* desc, const char* op, EvalFunc evalFunc, glu::Precision precision, int bits, const tcu::UVec2& rangeA, const tcu::UVec2& rangeB, bool isVertexCase)
 683         : TestCase                      (context, name, desc)
 684         , m_op                          (op)
 685         , m_evalFunc            (evalFunc)
 686         , m_precision           (precision)
 687         , m_bits                        (bits)
 688         , m_rangeA                      (rangeA)
 689         , m_rangeB                      (rangeB)
 690         , m_isVertexCase        (isVertexCase)
 691         , m_numTestsPerIter     (32)
 692         , m_numIters            (4)
 693         , m_rnd                         (deStringHash(name))
 694         , m_program                     (DE_NULL)
 695         , m_framebuffer         (0)
 696         , m_renderbuffer        (0)
 697         , m_iterNdx                     (0)
 698 {
 699 }
 700
 701 ShaderUintPrecisionCase::~ShaderUintPrecisionCase (void)
 702 {
 703         ShaderUintPrecisionCase::deinit();
 704 }
 705
 706 void ShaderUintPrecisionCase::init (void)
 707 {
 708         const glw::Functions&   gl      = m_context.getRenderContext().getFunctions();
 709         TestLog&                                log     = m_testCtx.getLog();
 710
 711         DE_ASSERT(!m_program && !m_framebuffer && !m_renderbuffer);
 712
 713         // Create program.
 714         m_program = createIntUintPrecisionEvalProgram(m_context.getRenderContext(), glu::TYPE_UINT, m_precision, m_op.c_str(), m_isVertexCase);
 715         log << *m_program;
 716
 717         TCU_CHECK(m_program->isOk());
 718
 719         // Create framebuffer.
 720         gl.genFramebuffers(1, &m_framebuffer);
 721         gl.genRenderbuffers(1, &m_renderbuffer);
 722
 723         gl.bindRenderbuffer(GL_RENDERBUFFER, m_renderbuffer);
 724         gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT);
 725
 726         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 727         gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_renderbuffer);
 728
 729         GLU_EXPECT_NO_ERROR(gl.getError(), "Post framebuffer setup");
 730         TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
 731
 732         gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer());
 733
 734         // Initialize test result to pass.
 735         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 736         m_iterNdx = 0;
 737
 738         log << TestLog::Message << "Number of accurate bits assumed = " << m_bits << TestLog::EndMessage;
 739 }
 740
 741 void ShaderUintPrecisionCase::deinit (void)
 742 {
 743         delete m_program;
 744
 745         if (m_framebuffer)
 746                 m_context.getRenderContext().getFunctions().deleteFramebuffers(1, &m_framebuffer);
 747
 748         if (m_renderbuffer)
 749                 m_context.getRenderContext().getFunctions().deleteRenderbuffers(1, &m_renderbuffer);
 750
 751         m_program               = DE_NULL;
 752         m_framebuffer   = 0;
 753         m_renderbuffer  = 0;
 754 }
 755
 756 ShaderUintPrecisionCase::IterateResult ShaderUintPrecisionCase::iterate (void)
 757 {
 758         // Constant data.
 759         const float position[] =
 760         {
 761                 -1.0f, -1.0f, 0.0f, 1.0f,
 762                 -1.0f,  1.0f, 0.0f, 1.0f,
 763                  1.0f, -1.0f, 0.0f, 1.0f,
 764                  1.0f,  1.0f, 0.0f, 1.0f
 765         };
 766         const deUint16                                  indices[]       = { 0, 1, 2, 2, 1, 3 };
 767
 768         const int                                               numVertices     = 4;
 769         deUint32                                                in0Arr[4]       = { 0 };
 770         deUint32                                                in1Arr[4]       = { 0 };
 771
 772         TestLog&                                                log                     = m_testCtx.getLog();
 773         const glw::Functions&                   gl                      = m_context.getRenderContext().getFunctions();
 774         deUint32                                                mask            = m_bits == 32 ? 0xffffffffu : ((1u<<m_bits)-1);
 775         vector<deUint32>                                pixels          (FRAMEBUFFER_WIDTH*FRAMEBUFFER_HEIGHT*4);
 776         vector<glu::VertexArrayBinding> vertexArrays;
 777
 778         deUint32                                                prog            = m_program->getProgram();
 779
 780         // \todo [2012-05-03 pyry] A bit hacky.
 781         bool                                                    isMaxRangeA     = m_rangeA.x() == 0 && m_rangeA.y() == 0xffffffff;
 782         bool                                                    isMaxRangeB     = m_rangeB.x() == 0 && m_rangeB.y() == 0xffffffff;
 783
 784         gl.useProgram(prog);
 785         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 786
 787         vertexArrays.push_back(glu::va::Float("a_position", 4, numVertices, 0, &position[0]));
 788         vertexArrays.push_back(glu::va::Uint32("a_in0", 1, numVertices, 0, &in0Arr[0]));
 789         vertexArrays.push_back(glu::va::Uint32("a_in1", 1, numVertices, 0, &in1Arr[0]));
 790
 791         GLU_EXPECT_NO_ERROR(gl.getError(), "After program setup");
 792
 793         // Compute values and reference.
 794         for (int testNdx = 0; testNdx < m_numTestsPerIter; testNdx++)
 795         {
 796                 deUint32        in0             = (isMaxRangeA ? m_rnd.getUint32() : (m_rangeA.x() + m_rnd.getUint32()%(m_rangeA.y()-m_rangeA.x()+1))) & mask;
 797                 deUint32        in1             = (isMaxRangeB ? m_rnd.getUint32() : (m_rangeB.x() + m_rnd.getUint32()%(m_rangeB.y()-m_rangeB.x()+1))) & mask;
 798                 deUint32        refOut  = m_evalFunc(in0, in1) & mask;
 799
 800                 log << TestLog::Message << "iter " << m_iterNdx << ", test " << testNdx << ": "
 801                                                                 << "in0 = " << tcu::toHex(in0) << ", in1 = " << tcu::toHex(in1) << ", ref out = " << tcu::toHex(refOut)
 802                         << TestLog::EndMessage;
 803
 804                 std::fill(&in0Arr[0], &in0Arr[0] + DE_LENGTH_OF_ARRAY(in0Arr), in0);
 805                 std::fill(&in1Arr[0], &in1Arr[0] + DE_LENGTH_OF_ARRAY(in1Arr), in1);
 806
 807                 glu::draw(m_context.getRenderContext(), prog, (int)vertexArrays.size(), &vertexArrays[0],
 808                                   glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
 809                 gl.readPixels(0, 0, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &pixels[0]);
 810                 GLU_EXPECT_NO_ERROR(gl.getError(), "After render");
 811
 812                 // Compare pixels.
 813                 for (int y = 0; y < FRAMEBUFFER_HEIGHT; y++)
 814                 {
 815                         for (int x = 0; x < FRAMEBUFFER_WIDTH; x++)
 816                         {
 817                                 deUint32        cmpOut          = pixels[(y*FRAMEBUFFER_WIDTH + x)*4];
 818                                 deUint32        cmpMasked       = cmpOut & mask;
 819
 820                                 if (cmpMasked != refOut)
 821                                 {
 822                                         log << TestLog::Message << "Comparison failed (at " << x << ", " << y << "): "
 823                                                                                         << "got " << tcu::toHex(cmpOut)
 824                                                 << TestLog::EndMessage;
 825                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 826                                         return STOP;
 827                                 }
 828                         }
 829                 }
 830         }
 831
 832         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 833         GLU_EXPECT_NO_ERROR(gl.getError(), "After iteration");
 834
 835         m_iterNdx += 1;
 836         return (m_iterNdx < m_numIters) ? CONTINUE : STOP;
 837 }
 838
 839 ShaderPrecisionTests::ShaderPrecisionTests (Context& context)
 840         : TestCaseGroup(context, "precision", "Shader precision requirements validation tests")
 841 {
 842 }
 843
 844 ShaderPrecisionTests::~ShaderPrecisionTests (void)
 845 {
 846 }
 847
 848 void ShaderPrecisionTests::init (void)
 849 {
 850         using tcu::add;
 851         using tcu::sub;
 852         using tcu::mul;
 853         using tcu::div;
 854         using tcu::Vec2;
 855         using tcu::IVec2;
 856         using tcu::UVec2;
 857
 858         // Exp = Emax-2, Mantissa = 0
 859         float           minF32                  = tcu::Float32((1u<<31) | (0xfdu<<23) | 0x0u).asFloat();
 860         float           maxF32                  = tcu::Float32((0u<<31) | (0xfdu<<23) | 0x0u).asFloat();
 861         float           minF16                  = tcu::Float16((deUint16)((1u<<15) | (0x1du<<10) | 0x0u)).asFloat();
 862         float           maxF16                  = tcu::Float16((deUint16)((0u<<15) | (0x1du<<10) | 0x0u)).asFloat();
 863         tcu::Vec2       fullRange32F    (minF32, maxF32);
 864         tcu::Vec2       fullRange16F    (minF16, maxF16);
 865         tcu::IVec2      fullRange32I    (0x80000000, 0x7fffffff);
 866         tcu::IVec2      fullRange16I    (-(1<<15), (1<<15)-1);
 867         tcu::IVec2      fullRange8I             (-(1<<7), (1<<7)-1);
 868         tcu::UVec2      fullRange32U    (0u, 0xffffffffu);
 869         tcu::UVec2      fullRange16U    (0u, 0xffffu);
 870         tcu::UVec2      fullRange8U             (0u, 0xffu);
 871
 872         // \note Right now it is not programmatically verified that the results shouldn't end up being inf/nan but
 873         //       actual values used are ok.
 874
 875         static const struct
 876         {
 877                 const char*                                                     name;
 878                 const char*                                                     op;
 879                 ShaderFloatPrecisionCase::EvalFunc      evalFunc;
 880                 glu::Precision                                          precision;
 881                 tcu::Vec2                                                       rangeA;
 882                 tcu::Vec2                                                       rangeB;
 883         } floatCases[] =
 884         {
 885                 // Name                         Op                              Eval                    Precision                               RangeA                          RangeB
 886                 { "highp_add",          "in0 + in1",    add<double>,    glu::PRECISION_HIGHP,   fullRange32F,           fullRange32F            },
 887                 { "highp_sub",          "in0 - in1",    sub<double>,    glu::PRECISION_HIGHP,   fullRange32F,           fullRange32F            },
 888                 { "highp_mul",          "in0 * in1",    mul<double>,    glu::PRECISION_HIGHP,   Vec2(-1e5f, 1e5f),      Vec2(-1e5f, 1e5f)       },
 889                 { "highp_div",          "in0 / in1",    div<double>,    glu::PRECISION_HIGHP,   Vec2(-1e5f, 1e5f),      Vec2(-1e5f, 1e5f)       },
 890                 { "mediump_add",        "in0 + in1",    add<double>,    glu::PRECISION_MEDIUMP, fullRange16F,           fullRange16F            },
 891                 { "mediump_sub",        "in0 - in1",    sub<double>,    glu::PRECISION_MEDIUMP, fullRange16F,           fullRange16F            },
 892                 { "mediump_mul",        "in0 * in1",    mul<double>,    glu::PRECISION_MEDIUMP, Vec2(-1e2f, 1e2f),      Vec2(-1e2f, 1e2f)       },
 893                 { "mediump_div",        "in0 / in1",    div<double>,    glu::PRECISION_MEDIUMP, Vec2(-1e2f, 1e2f),      Vec2(-1e2f, 1e2f)       }
 894         };
 895
 896         static const struct
 897         {
 898                 const char*                                                     name;
 899                 const char*                                                     op;
 900                 ShaderIntPrecisionCase::EvalFunc        evalFunc;
 901                 glu::Precision                                          precision;
 902                 int                                                                     bits;
 903                 tcu::IVec2                                                      rangeA;
 904                 tcu::IVec2                                                      rangeB;
 905         } intCases[] =
 906         {
 907                 // Name                         Op                              Eval                            Precision                               Bits    RangeA                  RangeB
 908                 { "highp_add",          "in0 + in1",    add<int>,                       glu::PRECISION_HIGHP,   32,             fullRange32I,   fullRange32I },
 909                 { "highp_sub",          "in0 - in1",    sub<int>,                       glu::PRECISION_HIGHP,   32,             fullRange32I,   fullRange32I },
 910                 { "highp_mul",          "in0 * in1",    mul<int>,                       glu::PRECISION_HIGHP,   32,             fullRange32I,   fullRange32I },
 911                 { "highp_div",          "in0 / in1",    div<int>,                       glu::PRECISION_HIGHP,   32,             fullRange32I,   IVec2(-10000, -1) },
 912                 { "mediump_add",        "in0 + in1",    add<int>,                       glu::PRECISION_MEDIUMP, 16,             fullRange16I,   fullRange16I },
 913                 { "mediump_sub",        "in0 - in1",    sub<int>,                       glu::PRECISION_MEDIUMP, 16,             fullRange16I,   fullRange16I },
 914                 { "mediump_mul",        "in0 * in1",    mul<int>,                       glu::PRECISION_MEDIUMP, 16,             fullRange16I,   fullRange16I },
 915                 { "mediump_div",        "in0 / in1",    div<int>,                       glu::PRECISION_MEDIUMP, 16,             fullRange16I,   IVec2(1, 1000) },
 916                 { "lowp_add",           "in0 + in1",    add<int>,                       glu::PRECISION_LOWP,    8,              fullRange8I,    fullRange8I },
 917                 { "lowp_sub",           "in0 - in1",    sub<int>,                       glu::PRECISION_LOWP,    8,              fullRange8I,    fullRange8I },
 918                 { "lowp_mul",           "in0 * in1",    mul<int>,                       glu::PRECISION_LOWP,    8,              fullRange8I,    fullRange8I },
 919                 { "lowp_div",           "in0 / in1",    div<int>,                       glu::PRECISION_LOWP,    8,              fullRange8I,    IVec2(-50, -1) }
 920         };
 921
 922         static const struct
 923         {
 924                 const char*                                                     name;
 925                 const char*                                                     op;
 926                 ShaderUintPrecisionCase::EvalFunc       evalFunc;
 927                 glu::Precision                                          precision;
 928                 int                                                                     bits;
 929                 tcu::UVec2                                                      rangeA;
 930                 tcu::UVec2                                                      rangeB;
 931         } uintCases[] =
 932         {
 933                 // Name                         Op                              Eval                            Precision                               Bits    RangeA                  RangeB
 934                 { "highp_add",          "in0 + in1",    add<deUint32>,          glu::PRECISION_HIGHP,   32,             fullRange32U,   fullRange32U },
 935                 { "highp_sub",          "in0 - in1",    sub<deUint32>,          glu::PRECISION_HIGHP,   32,             fullRange32U,   fullRange32U },
 936                 { "highp_mul",          "in0 * in1",    mul<deUint32>,          glu::PRECISION_HIGHP,   32,             fullRange32U,   fullRange32U },
 937                 { "highp_div",          "in0 / in1",    div<deUint32>,          glu::PRECISION_HIGHP,   32,             fullRange32U,   UVec2(1u, 10000u) },
 938                 { "mediump_add",        "in0 + in1",    add<deUint32>,          glu::PRECISION_MEDIUMP, 16,             fullRange16U,   fullRange16U },
 939                 { "mediump_sub",        "in0 - in1",    sub<deUint32>,          glu::PRECISION_MEDIUMP, 16,             fullRange16U,   fullRange16U },
 940                 { "mediump_mul",        "in0 * in1",    mul<deUint32>,          glu::PRECISION_MEDIUMP, 16,             fullRange16U,   fullRange16U },
 941                 { "mediump_div",        "in0 / in1",    div<deUint32>,          glu::PRECISION_MEDIUMP, 16,             fullRange16U,   UVec2(1, 1000u) },
 942                 { "lowp_add",           "in0 + in1",    add<deUint32>,          glu::PRECISION_LOWP,    8,              fullRange8U,    fullRange8U },
 943                 { "lowp_sub",           "in0 - in1",    sub<deUint32>,          glu::PRECISION_LOWP,    8,              fullRange8U,    fullRange8U },
 944                 { "lowp_mul",           "in0 * in1",    mul<deUint32>,          glu::PRECISION_LOWP,    8,              fullRange8U,    fullRange8U },
 945                 { "lowp_div",           "in0 / in1",    div<deUint32>,          glu::PRECISION_LOWP,    8,              fullRange8U,    UVec2(1, 50u) }
 946         };
 947
 948         tcu::TestCaseGroup* floatGroup = new tcu::TestCaseGroup(m_testCtx, "float", "Floating-point precision tests");
 949         addChild(floatGroup);
 950         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(floatCases); ndx++)
 951         {
 952                 floatGroup->addChild(new ShaderFloatPrecisionCase(m_context,
 953                                                                                                                   (string(floatCases[ndx].name) + "_vertex").c_str(), "",
 954                                                                                                                   floatCases[ndx].op,
 955                                                                                                                   floatCases[ndx].evalFunc,
 956                                                                                                                   floatCases[ndx].precision,
 957                                                                                                                   floatCases[ndx].rangeA,
 958                                                                                                                   floatCases[ndx].rangeB,
 959                                                                                                                   true));
 960                 floatGroup->addChild(new ShaderFloatPrecisionCase(m_context,
 961                                                                                                                   (string(floatCases[ndx].name) + "_fragment").c_str(), "",
 962                                                                                                                   floatCases[ndx].op,
 963                                                                                                                   floatCases[ndx].evalFunc,
 964                                                                                                                   floatCases[ndx].precision,
 965                                                                                                                   floatCases[ndx].rangeA,
 966                                                                                                                   floatCases[ndx].rangeB,
 967                                                                                                                   false));
 968         }
 969
 970         tcu::TestCaseGroup* intGroup = new tcu::TestCaseGroup(m_testCtx, "int", "Integer precision tests");
 971         addChild(intGroup);
 972         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(intCases); ndx++)
 973         {
 974                 intGroup->addChild(new ShaderIntPrecisionCase(m_context,
 975                                                                                                           (string(intCases[ndx].name) + "_vertex").c_str(), "",
 976                                                                                                           intCases[ndx].op,
 977                                                                                                           intCases[ndx].evalFunc,
 978                                                                                                           intCases[ndx].precision,
 979                                                                                                           intCases[ndx].bits,
 980                                                                                                           intCases[ndx].rangeA,
 981                                                                                                           intCases[ndx].rangeB,
 982                                                                                                           true));
 983                 intGroup->addChild(new ShaderIntPrecisionCase(m_context,
 984                                                                                                           (string(intCases[ndx].name) + "_fragment").c_str(), "",
 985                                                                                                           intCases[ndx].op,
 986                                                                                                           intCases[ndx].evalFunc,
 987                                                                                                           intCases[ndx].precision,
 988                                                                                                           intCases[ndx].bits,
 989                                                                                                           intCases[ndx].rangeA,
 990                                                                                                           intCases[ndx].rangeB,
 991                                                                                                           false));
 992         }
 993
 994         tcu::TestCaseGroup* uintGroup = new tcu::TestCaseGroup(m_testCtx, "uint", "Unsigned integer precision tests");
 995         addChild(uintGroup);
 996         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uintCases); ndx++)
 997         {
 998                 uintGroup->addChild(new ShaderUintPrecisionCase(m_context,
 999                                                                                                                 (string(uintCases[ndx].name) + "_vertex").c_str(), "",
1000                                                                                                                 uintCases[ndx].op,
1001                                                                                                                 uintCases[ndx].evalFunc,
1002                                                                                                                 uintCases[ndx].precision,
1003                                                                                                                 uintCases[ndx].bits,
1004                                                                                                                 uintCases[ndx].rangeA,
1005                                                                                                                 uintCases[ndx].rangeB,
1006                                                                                                                 true));
1007                 uintGroup->addChild(new ShaderUintPrecisionCase(m_context,
1008                                                                                                                 (string(uintCases[ndx].name) + "_fragment").c_str(), "",
1009                                                                                                                 uintCases[ndx].op,
1010                                                                                                                 uintCases[ndx].evalFunc,
1011                                                                                                                 uintCases[ndx].precision,
1012                                                                                                                 uintCases[ndx].bits,
1013                                                                                                                 uintCases[ndx].rangeA,
1014                                                                                                                 uintCases[ndx].rangeB,
1015                                                                                                                 false));
1016         }
1017 }
1018
1019 } // Functional
1020 } // gles3
1021 } // deqp