modules/glshared/glsShaderRenderCase.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL (ES) Module
   3  * -----------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader execute test.
  22  *
  23  * \todo [petri] Multiple grid with differing constants/uniforms.
  24  * \todo [petri]
  25  *//*--------------------------------------------------------------------*/
  26
  27 #include "glsShaderRenderCase.hpp"
  28
  29 #include "tcuSurface.hpp"
  30 #include "tcuVector.hpp"
  31 #include "tcuImageCompare.hpp"
  32 #include "tcuTestLog.hpp"
  33 #include "tcuRenderTarget.hpp"
  34
  35 #include "gluPixelTransfer.hpp"
  36 #include "gluTexture.hpp"
  37 #include "gluTextureUtil.hpp"
  38 #include "gluDrawUtil.hpp"
  39
  40 #include "glwFunctions.hpp"
  41 #include "glwEnums.hpp"
  42
  43 #include "deRandom.hpp"
  44 #include "deMemory.h"
  45 #include "deString.h"
  46 #include "deMath.h"
  47 #include "deStringUtil.hpp"
  48
  49 #include <stdio.h>
  50 #include <vector>
  51 #include <string>
  52
  53 namespace deqp
  54 {
  55 namespace gls
  56 {
  57
  58 using namespace std;
  59 using namespace tcu;
  60 using namespace glu;
  61
  62 static const int                        GRID_SIZE                               = 64;
  63 static const int                        MAX_RENDER_WIDTH                = 128;
  64 static const int                        MAX_RENDER_HEIGHT               = 112;
  65 static const tcu::Vec4          DEFAULT_CLEAR_COLOR             = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f);
  66
  67 inline RGBA toRGBA (const Vec4& a)
  68 {
  69         return RGBA(deClamp32(deRoundFloatToInt32(a.x() * 255.0f), 0, 255),
  70                                 deClamp32(deRoundFloatToInt32(a.y() * 255.0f), 0, 255),
  71                                 deClamp32(deRoundFloatToInt32(a.z() * 255.0f), 0, 255),
  72                                 deClamp32(deRoundFloatToInt32(a.w() * 255.0f), 0, 255));
  73 }
  74
  75 inline tcu::Vec4 toVec (const RGBA& c)
  76 {
  77         return tcu::Vec4(c.getRed()             / 255.0f,
  78                                          c.getGreen()   / 255.0f,
  79                                          c.getBlue()    / 255.0f,
  80                                          c.getAlpha()   / 255.0f);
  81 }
  82
  83 // TextureBinding
  84
  85 TextureBinding::TextureBinding (const glu::Texture2D* tex2D, const tcu::Sampler& sampler)
  86         : m_type        (TYPE_2D)
  87         , m_sampler     (sampler)
  88 {
  89         m_binding.tex2D = tex2D;
  90 }
  91
  92 TextureBinding::TextureBinding (const glu::TextureCube* texCube, const tcu::Sampler& sampler)
  93         : m_type        (TYPE_CUBE_MAP)
  94         , m_sampler     (sampler)
  95 {
  96         m_binding.texCube = texCube;
  97 }
  98
  99 TextureBinding::TextureBinding (const glu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler)
 100         : m_type        (TYPE_2D_ARRAY)
 101         , m_sampler     (sampler)
 102 {
 103         m_binding.tex2DArray = tex2DArray;
 104 }
 105
 106 TextureBinding::TextureBinding (const glu::Texture3D* tex3D, const tcu::Sampler& sampler)
 107         : m_type        (TYPE_3D)
 108         , m_sampler     (sampler)
 109 {
 110         m_binding.tex3D = tex3D;
 111 }
 112
 113 TextureBinding::TextureBinding (void)
 114         : m_type        (TYPE_NONE)
 115 {
 116         m_binding.tex2D = DE_NULL;
 117 }
 118
 119 void TextureBinding::setSampler (const tcu::Sampler& sampler)
 120 {
 121         m_sampler = sampler;
 122 }
 123
 124 void TextureBinding::setTexture (const glu::Texture2D* tex2D)
 125 {
 126         m_type                  = TYPE_2D;
 127         m_binding.tex2D = tex2D;
 128 }
 129
 130 void TextureBinding::setTexture (const glu::TextureCube* texCube)
 131 {
 132         m_type                          = TYPE_CUBE_MAP;
 133         m_binding.texCube       = texCube;
 134 }
 135
 136 void TextureBinding::setTexture (const glu::Texture2DArray* tex2DArray)
 137 {
 138         m_type                                  = TYPE_2D_ARRAY;
 139         m_binding.tex2DArray    = tex2DArray;
 140 }
 141
 142 void TextureBinding::setTexture (const glu::Texture3D* tex3D)
 143 {
 144         m_type                  = TYPE_3D;
 145         m_binding.tex3D = tex3D;
 146 }
 147
 148 // QuadGrid.
 149
 150 class QuadGrid
 151 {
 152 public:
 153                                                         QuadGrid                                (int gridSize, int screenWidth, int screenHeight, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures);
 154                                                         ~QuadGrid                               (void);
 155
 156         int                                             getGridSize                             (void) const { return m_gridSize; }
 157         int                                             getNumVertices                  (void) const { return m_numVertices; }
 158         int                                             getNumTriangles                 (void) const { return m_numTriangles; }
 159         const Vec4&                             getConstCoords                  (void) const { return m_constCoords; }
 160         const vector<Mat4>              getUserAttribTransforms (void) const { return m_userAttribTransforms; }
 161         const vector<TextureBinding>&   getTextures             (void) const { return m_textures; }
 162
 163         const Vec4*                             getPositions                    (void) const { return &m_positions[0]; }
 164         const float*                    getAttribOne                    (void) const { return &m_attribOne[0]; }
 165         const Vec4*                             getCoords                               (void) const { return &m_coords[0]; }
 166         const Vec4*                             getUnitCoords                   (void) const { return &m_unitCoords[0]; }
 167         const Vec4*                             getUserAttrib                   (int attribNdx) const { return &m_userAttribs[attribNdx][0]; }
 168         const deUint16*                 getIndices                              (void) const { return &m_indices[0]; }
 169
 170         Vec4                                    getCoords                               (float sx, float sy) const;
 171         Vec4                                    getUnitCoords                   (float sx, float sy) const;
 172
 173         int                                             getNumUserAttribs               (void) const { return (int)m_userAttribTransforms.size(); }
 174         Vec4                                    getUserAttrib                   (int attribNdx, float sx, float sy) const;
 175
 176 private:
 177         int                                             m_gridSize;
 178         int                                             m_numVertices;
 179         int                                             m_numTriangles;
 180         Vec4                                    m_constCoords;
 181         vector<Mat4>                    m_userAttribTransforms;
 182         vector<TextureBinding>  m_textures;
 183
 184         vector<Vec4>                    m_screenPos;
 185         vector<Vec4>                    m_positions;
 186         vector<Vec4>                    m_coords;                       //!< Near-unit coordinates, roughly [-2.0 .. 2.0].
 187         vector<Vec4>                    m_unitCoords;           //!< Positive-only coordinates [0.0 .. 1.5].
 188         vector<float>                   m_attribOne;
 189         vector<Vec4>                    m_userAttribs[ShaderEvalContext::MAX_TEXTURES];
 190         vector<deUint16>                m_indices;
 191 };
 192
 193 QuadGrid::QuadGrid (int gridSize, int width, int height, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures)
 194         : m_gridSize                            (gridSize)
 195         , m_numVertices                         ((gridSize + 1) * (gridSize + 1))
 196         , m_numTriangles                        (gridSize * gridSize * 2)
 197         , m_constCoords                         (constCoords)
 198         , m_userAttribTransforms        (userAttribTransforms)
 199         , m_textures                            (textures)
 200 {
 201         Vec4 viewportScale = Vec4((float)width, (float)height, 0.0f, 0.0f);
 202
 203         // Compute vertices.
 204         m_positions.resize(m_numVertices);
 205         m_coords.resize(m_numVertices);
 206         m_unitCoords.resize(m_numVertices);
 207         m_attribOne.resize(m_numVertices);
 208         m_screenPos.resize(m_numVertices);
 209
 210         // User attributes.
 211         for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_userAttribs); i++)
 212                 m_userAttribs[i].resize(m_numVertices);
 213
 214         for (int y = 0; y < gridSize+1; y++)
 215         for (int x = 0; x < gridSize+1; x++)
 216         {
 217                 float                           sx                      = x / (float)gridSize;
 218                 float                           sy                      = y / (float)gridSize;
 219                 float                           fx                      = 2.0f * sx - 1.0f;
 220                 float                           fy                      = 2.0f * sy - 1.0f;
 221                 int                                     vtxNdx          = ((y * (gridSize+1)) + x);
 222
 223                 m_positions[vtxNdx]             = Vec4(fx, fy, 0.0f, 1.0f);
 224                 m_attribOne[vtxNdx]             = 1.0f;
 225                 m_screenPos[vtxNdx]             = Vec4(sx, sy, 0.0f, 1.0f) * viewportScale;
 226                 m_coords[vtxNdx]                = getCoords(sx, sy);
 227                 m_unitCoords[vtxNdx]    = getUnitCoords(sx, sy);
 228
 229                 for (int attribNdx = 0; attribNdx < getNumUserAttribs(); attribNdx++)
 230                         m_userAttribs[attribNdx][vtxNdx] = getUserAttrib(attribNdx, sx, sy);
 231         }
 232
 233         // Compute indices.
 234         m_indices.resize(3 * m_numTriangles);
 235         for (int y = 0; y < gridSize; y++)
 236         for (int x = 0; x < gridSize; x++)
 237         {
 238                 int stride = gridSize + 1;
 239                 int v00 = (y * stride) + x;
 240                 int v01 = (y * stride) + x + 1;
 241                 int v10 = ((y+1) * stride) + x;
 242                 int v11 = ((y+1) * stride) + x + 1;
 243
 244                 int baseNdx = ((y * gridSize) + x) * 6;
 245                 m_indices[baseNdx + 0] = v10;
 246                 m_indices[baseNdx + 1] = v00;
 247                 m_indices[baseNdx + 2] = v01;
 248
 249                 m_indices[baseNdx + 3] = v10;
 250                 m_indices[baseNdx + 4] = v01;
 251                 m_indices[baseNdx + 5] = v11;
 252         }
 253 }
 254
 255 QuadGrid::~QuadGrid (void)
 256 {
 257 }
 258
 259 inline Vec4 QuadGrid::getCoords (float sx, float sy) const
 260 {
 261         float fx = 2.0f * sx - 1.0f;
 262         float fy = 2.0f * sy - 1.0f;
 263         return Vec4(fx, fy, -fx + 0.33f*fy, -0.275f*fx - fy);
 264 }
 265
 266 inline Vec4 QuadGrid::getUnitCoords (float sx, float sy) const
 267 {
 268         return Vec4(sx, sy, 0.33f*sx + 0.5f*sy, 0.5f*sx + 0.25f*sy);
 269 }
 270
 271 inline Vec4 QuadGrid::getUserAttrib (int attribNdx, float sx, float sy) const
 272 {
 273         // homogeneous normalized screen-space coordinates
 274         return m_userAttribTransforms[attribNdx] * Vec4(sx, sy, 0.0f, 1.0f);
 275 }
 276
 277 // ShaderEvalContext.
 278
 279 ShaderEvalContext::ShaderEvalContext (const QuadGrid& quadGrid_)
 280         : constCoords   (quadGrid_.getConstCoords())
 281         , isDiscarded   (false)
 282         , quadGrid              (quadGrid_)
 283 {
 284         const vector<TextureBinding>& bindings = quadGrid.getTextures();
 285         DE_ASSERT((int)bindings.size() <= MAX_TEXTURES);
 286
 287         // Fill in texture array.
 288         for (int ndx = 0; ndx < (int)bindings.size(); ndx++)
 289         {
 290                 const TextureBinding& binding = bindings[ndx];
 291
 292                 if (binding.getType() == TextureBinding::TYPE_NONE)
 293                         continue;
 294
 295                 textures[ndx].sampler = binding.getSampler();
 296
 297                 switch (binding.getType())
 298                 {
 299                         case TextureBinding::TYPE_2D:           textures[ndx].tex2D                     = &binding.get2D()->getRefTexture();            break;
 300                         case TextureBinding::TYPE_CUBE_MAP:     textures[ndx].texCube           = &binding.getCube()->getRefTexture();          break;
 301                         case TextureBinding::TYPE_2D_ARRAY:     textures[ndx].tex2DArray        = &binding.get2DArray()->getRefTexture();       break;
 302                         case TextureBinding::TYPE_3D:           textures[ndx].tex3D                     = &binding.get3D()->getRefTexture();            break;
 303                         default:
 304                                 DE_ASSERT(DE_FALSE);
 305                 }
 306         }
 307 }
 308
 309 ShaderEvalContext::~ShaderEvalContext (void)
 310 {
 311 }
 312
 313 void ShaderEvalContext::reset (float sx, float sy)
 314 {
 315         // Clear old values
 316         color           = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
 317         isDiscarded     = false;
 318
 319         // Compute coords
 320         coords          = quadGrid.getCoords(sx, sy);
 321         unitCoords      = quadGrid.getUnitCoords(sx, sy);
 322
 323         // Compute user attributes.
 324         int numAttribs = quadGrid.getNumUserAttribs();
 325         DE_ASSERT(numAttribs <= MAX_USER_ATTRIBS);
 326         for (int attribNdx = 0; attribNdx < numAttribs; attribNdx++)
 327                 in[attribNdx] = quadGrid.getUserAttrib(attribNdx, sx, sy);
 328 }
 329
 330 tcu::Vec4 ShaderEvalContext::texture2D (int unitNdx, const tcu::Vec2& texCoords)
 331 {
 332         if (textures[unitNdx].tex2D)
 333                 return textures[unitNdx].tex2D->sample(textures[unitNdx].sampler, texCoords.x(), texCoords.y(), 0.0f);
 334         else
 335                 return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
 336 }
 337
 338 // ShaderEvaluator
 339
 340 ShaderEvaluator::ShaderEvaluator (void)
 341         : m_evalFunc(DE_NULL)
 342 {
 343 }
 344
 345 ShaderEvaluator::ShaderEvaluator (ShaderEvalFunc evalFunc)
 346         : m_evalFunc(evalFunc)
 347 {
 348 }
 349
 350 ShaderEvaluator::~ShaderEvaluator (void)
 351 {
 352 }
 353
 354 void ShaderEvaluator::evaluate (ShaderEvalContext& ctx)
 355 {
 356         DE_ASSERT(m_evalFunc);
 357         m_evalFunc(ctx);
 358 }
 359
 360 // ShaderRenderCase.
 361
 362 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc)
 363         : TestCase                              (testCtx, name, description)
 364         , m_renderCtx                   (renderCtx)
 365         , m_ctxInfo                             (ctxInfo)
 366         , m_isVertexCase                (isVertexCase)
 367         , m_defaultEvaluator    (evalFunc)
 368         , m_evaluator                   (m_defaultEvaluator)
 369         , m_clearColor                  (DEFAULT_CLEAR_COLOR)
 370         , m_program                             (DE_NULL)
 371 {
 372 }
 373
 374 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvaluator& evaluator)
 375         : TestCase                              (testCtx, name, description)
 376         , m_renderCtx                   (renderCtx)
 377         , m_ctxInfo                             (ctxInfo)
 378         , m_isVertexCase                (isVertexCase)
 379         , m_defaultEvaluator    (DE_NULL)
 380         , m_evaluator                   (evaluator)
 381         , m_clearColor                  (DEFAULT_CLEAR_COLOR)
 382         , m_program                             (DE_NULL)
 383 {
 384 }
 385
 386 ShaderRenderCase::~ShaderRenderCase (void)
 387 {
 388         ShaderRenderCase::deinit();
 389 }
 390
 391 void ShaderRenderCase::init (void)
 392 {
 393         TestLog&                                log             = m_testCtx.getLog();
 394         const glw::Functions&   gl              = m_renderCtx.getFunctions();
 395
 396         GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() begin");
 397
 398         if (m_vertShaderSource.empty() || m_fragShaderSource.empty())
 399         {
 400                 DE_ASSERT(m_vertShaderSource.empty() && m_fragShaderSource.empty());
 401                 setupShaderData();
 402         }
 403
 404         DE_ASSERT(!m_program);
 405         m_program = new ShaderProgram(m_renderCtx, makeVtxFragSources(m_vertShaderSource, m_fragShaderSource));
 406
 407         try
 408         {
 409                 log << *m_program; // Always log shader program.
 410
 411                 if (!m_program->isOk())
 412                         throw CompileFailed(__FILE__, __LINE__);
 413
 414                 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() end");
 415         }
 416         catch (const std::exception&)
 417         {
 418                 // Clean up.
 419                 ShaderRenderCase::deinit();
 420                 throw;
 421         }
 422 }
 423
 424 void ShaderRenderCase::deinit (void)
 425 {
 426         delete m_program;
 427         m_program = DE_NULL;
 428 }
 429
 430 tcu::IVec2 ShaderRenderCase::getViewportSize (void) const
 431 {
 432         return tcu::IVec2(de::min(m_renderCtx.getRenderTarget().getWidth(), MAX_RENDER_WIDTH),
 433                                           de::min(m_renderCtx.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT));
 434 }
 435
 436 TestNode::IterateResult ShaderRenderCase::iterate (void)
 437 {
 438         const glw::Functions& gl = m_renderCtx.getFunctions();
 439
 440         GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::iterate() begin");
 441
 442         DE_ASSERT(m_program);
 443         deUint32 programID = m_program->getProgram();
 444         gl.useProgram(programID);
 445
 446         // Create quad grid.
 447         IVec2   viewportSize    = getViewportSize();
 448         int             width                   = viewportSize.x();
 449         int             height                  = viewportSize.y();
 450
 451         // \todo [petri] Better handling of constCoords (render in multiple chunks, vary coords).
 452         QuadGrid quadGrid(m_isVertexCase ? GRID_SIZE : 4, width, height, Vec4(0.125f, 0.25f, 0.5f, 1.0f), m_userAttribTransforms, m_textures);
 453
 454         // Render result.
 455         Surface resImage(width, height);
 456         render(resImage, programID, quadGrid);
 457
 458         // Compute reference.
 459         Surface refImage (width, height);
 460         if (m_isVertexCase)
 461                 computeVertexReference(refImage, quadGrid);
 462         else
 463                 computeFragmentReference(refImage, quadGrid);
 464
 465         // Compare.
 466         bool testOk = compareImages(resImage, refImage, 0.05f);
 467
 468         // De-initialize.
 469         gl.useProgram(0);
 470
 471         m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS    : QP_TEST_RESULT_FAIL,
 472                                                         testOk ? "Pass"                                 : "Fail");
 473         return TestNode::STOP;
 474 }
 475
 476 void ShaderRenderCase::setupShaderData (void)
 477 {
 478 }
 479
 480 void ShaderRenderCase::setup (int programID)
 481 {
 482         DE_UNREF(programID);
 483 }
 484
 485 void ShaderRenderCase::setupUniforms (int programID, const Vec4& constCoords)
 486 {
 487         DE_UNREF(programID);
 488         DE_UNREF(constCoords);
 489 }
 490
 491 void ShaderRenderCase::setupDefaultInputs (int programID)
 492 {
 493         const glw::Functions& gl = m_renderCtx.getFunctions();
 494
 495         // SETUP UNIFORMS.
 496
 497         setupDefaultUniforms(m_renderCtx, programID);
 498
 499         GLU_EXPECT_NO_ERROR(gl.getError(), "post uniform setup");
 500
 501         // SETUP TEXTURES.
 502
 503         for (int ndx = 0; ndx < (int)m_textures.size(); ndx++)
 504         {
 505                 const TextureBinding&   tex                     = m_textures[ndx];
 506                 const tcu::Sampler&             sampler         = tex.getSampler();
 507                 deUint32                                texTarget       = GL_NONE;
 508                 deUint32                                texObj          = 0;
 509
 510                 if (tex.getType() == TextureBinding::TYPE_NONE)
 511                         continue;
 512
 513                 // Feature check.
 514                 if (m_renderCtx.getType().getAPI() == glu::ApiType::es(2,0))
 515                 {
 516                         if (tex.getType() == TextureBinding::TYPE_2D_ARRAY)
 517                                 throw tcu::NotSupportedError("2D array texture binding is not supported");
 518
 519                         if (tex.getType() == TextureBinding::TYPE_3D)
 520                                 throw tcu::NotSupportedError("3D texture binding is not supported");
 521
 522                         if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE)
 523                                 throw tcu::NotSupportedError("Shadow lookups are not supported");
 524                 }
 525
 526                 switch (tex.getType())
 527                 {
 528                         case TextureBinding::TYPE_2D:           texTarget = GL_TEXTURE_2D;                      texObj = tex.get2D()->getGLTexture();           break;
 529                         case TextureBinding::TYPE_CUBE_MAP:     texTarget = GL_TEXTURE_CUBE_MAP;        texObj = tex.getCube()->getGLTexture();         break;
 530                         case TextureBinding::TYPE_2D_ARRAY:     texTarget = GL_TEXTURE_2D_ARRAY;        texObj = tex.get2DArray()->getGLTexture();      break;
 531                         case TextureBinding::TYPE_3D:           texTarget = GL_TEXTURE_3D;                      texObj = tex.get3D()->getGLTexture();           break;
 532                         default:
 533                                 DE_ASSERT(DE_FALSE);
 534                 }
 535
 536                 gl.activeTexture(GL_TEXTURE0+ndx);
 537                 gl.bindTexture(texTarget, texObj);
 538                 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_S,          glu::getGLWrapMode(sampler.wrapS));
 539                 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_T,          glu::getGLWrapMode(sampler.wrapT));
 540                 gl.texParameteri(texTarget, GL_TEXTURE_MIN_FILTER,      glu::getGLFilterMode(sampler.minFilter));
 541                 gl.texParameteri(texTarget, GL_TEXTURE_MAG_FILTER,      glu::getGLFilterMode(sampler.magFilter));
 542
 543                 if (texTarget == GL_TEXTURE_3D)
 544                         gl.texParameteri(texTarget, GL_TEXTURE_WRAP_R, glu::getGLWrapMode(sampler.wrapR));
 545
 546                 if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE)
 547                 {
 548                         gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
 549                         gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_FUNC, glu::getGLCompareFunc(sampler.compare));
 550                 }
 551         }
 552
 553         GLU_EXPECT_NO_ERROR(gl.getError(), "texture sampler setup");
 554 }
 555
 556 static void getDefaultVertexArrays (const glw::Functions& gl, const QuadGrid& quadGrid, deUint32 program, vector<VertexArrayBinding>& vertexArrays)
 557 {
 558         const int numElements = quadGrid.getNumVertices();
 559
 560         vertexArrays.push_back(va::Float("a_position",          4, numElements, 0, (const float*)quadGrid.getPositions()));
 561         vertexArrays.push_back(va::Float("a_coords",            4, numElements, 0, (const float*)quadGrid.getCoords()));
 562         vertexArrays.push_back(va::Float("a_unitCoords",        4, numElements, 0, (const float*)quadGrid.getUnitCoords()));
 563         vertexArrays.push_back(va::Float("a_one",                       1, numElements, 0, quadGrid.getAttribOne()));
 564
 565         // a_inN.
 566         for (int userNdx = 0; userNdx < quadGrid.getNumUserAttribs(); userNdx++)
 567         {
 568                 string name = string("a_in") + de::toString(userNdx);
 569                 vertexArrays.push_back(va::Float(name, 4, numElements, 0, (const float*)quadGrid.getUserAttrib(userNdx)));
 570         }
 571
 572         // Matrix attributes - these are set by location
 573         static const struct
 574         {
 575                 const char*     name;
 576                 int                     numCols;
 577                 int                     numRows;
 578         } matrices[] =
 579         {
 580                 { "a_mat2",             2, 2 },
 581                 { "a_mat2x3",   2, 3 },
 582                 { "a_mat2x4",   2, 4 },
 583                 { "a_mat3x2",   3, 2 },
 584                 { "a_mat3",             3, 3 },
 585                 { "a_mat3x4",   3, 4 },
 586                 { "a_mat4x2",   4, 2 },
 587                 { "a_mat4x3",   4, 3 },
 588                 { "a_mat4",             4, 4 }
 589         };
 590
 591         for (int matNdx = 0; matNdx < DE_LENGTH_OF_ARRAY(matrices); matNdx++)
 592         {
 593                 int loc = gl.getAttribLocation(program, matrices[matNdx].name);
 594
 595                 if (loc < 0)
 596                         continue; // Not used in shader.
 597
 598                 int numRows     = matrices[matNdx].numRows;
 599                 int numCols     = matrices[matNdx].numCols;
 600
 601                 for (int colNdx = 0; colNdx < numCols; colNdx++)
 602                         vertexArrays.push_back(va::Float(loc+colNdx, numRows, numElements, 4*(int)sizeof(float), (const float*)quadGrid.getUserAttrib(colNdx)));
 603         }
 604 }
 605
 606 void ShaderRenderCase::render (Surface& result, int programID, const QuadGrid& quadGrid)
 607 {
 608         const glw::Functions& gl = m_renderCtx.getFunctions();
 609
 610         GLU_EXPECT_NO_ERROR(gl.getError(), "pre render");
 611
 612         // Buffer info.
 613         int                             width           = result.getWidth();
 614         int                             height          = result.getHeight();
 615
 616         int                             xOffsetMax      = m_renderCtx.getRenderTarget().getWidth() - width;
 617         int                             yOffsetMax      = m_renderCtx.getRenderTarget().getHeight() - height;
 618
 619         deUint32                hash            = deStringHash(m_vertShaderSource.c_str()) + deStringHash(m_fragShaderSource.c_str());
 620         de::Random              rnd                     (hash);
 621
 622         int                             xOffset         = rnd.getInt(0, xOffsetMax);
 623         int                             yOffset         = rnd.getInt(0, yOffsetMax);
 624
 625         gl.viewport(xOffset, yOffset, width, height);
 626
 627         // Setup program.
 628         setupUniforms(programID, quadGrid.getConstCoords());
 629         setupDefaultInputs(programID);
 630
 631         // Clear.
 632         gl.clearColor(m_clearColor.x(), m_clearColor.y(), m_clearColor.z(), m_clearColor.w());
 633         gl.clear(GL_COLOR_BUFFER_BIT);
 634
 635         // Draw.
 636         {
 637                 std::vector<VertexArrayBinding> vertexArrays;
 638                 const int                                               numElements             = quadGrid.getNumTriangles()*3;
 639
 640                 getDefaultVertexArrays(gl, quadGrid, programID, vertexArrays);
 641                 draw(m_renderCtx, programID, (int)vertexArrays.size(), &vertexArrays[0], pr::Triangles(numElements, quadGrid.getIndices()));
 642         }
 643         GLU_EXPECT_NO_ERROR(gl.getError(), "draw");
 644
 645         // Read back results.
 646         glu::readPixels(m_renderCtx, xOffset, yOffset, result.getAccess());
 647
 648         GLU_EXPECT_NO_ERROR(gl.getError(), "post render");
 649 }
 650
 651 void ShaderRenderCase::computeVertexReference (Surface& result, const QuadGrid& quadGrid)
 652 {
 653         // Buffer info.
 654         int                                     width           = result.getWidth();
 655         int                                     height          = result.getHeight();
 656         int                                     gridSize        = quadGrid.getGridSize();
 657         int                                     stride          = gridSize + 1;
 658         bool                            hasAlpha        = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
 659         ShaderEvalContext       evalCtx         (quadGrid);
 660
 661         // Evaluate color for each vertex.
 662         vector<Vec4> colors((gridSize+1)*(gridSize+1));
 663         for (int y = 0; y < gridSize+1; y++)
 664         for (int x = 0; x < gridSize+1; x++)
 665         {
 666                 float                           sx                      = x / (float)gridSize;
 667                 float                           sy                      = y / (float)gridSize;
 668                 int                                     vtxNdx          = ((y * (gridSize+1)) + x);
 669
 670                 evalCtx.reset(sx, sy);
 671                 m_evaluator.evaluate(evalCtx);
 672                 DE_ASSERT(!evalCtx.isDiscarded); // Discard is not available in vertex shader.
 673                 Vec4 color = evalCtx.color;
 674
 675                 if (!hasAlpha)
 676                         color.w() = 1.0f;
 677
 678                 colors[vtxNdx] = color;
 679         }
 680
 681         // Render quads.
 682         for (int y = 0; y < gridSize; y++)
 683         for (int x = 0; x < gridSize; x++)
 684         {
 685                 float x0 = x / (float)gridSize;
 686                 float x1 = (x + 1) / (float)gridSize;
 687                 float y0 = y / (float)gridSize;
 688                 float y1 = (y + 1) / (float)gridSize;
 689
 690                 float sx0 = x0 * (float)width;
 691                 float sx1 = x1 * (float)width;
 692                 float sy0 = y0 * (float)height;
 693                 float sy1 = y1 * (float)height;
 694                 float oosx = 1.0f / (sx1 - sx0);
 695                 float oosy = 1.0f / (sy1 - sy0);
 696
 697                 int ix0 = deCeilFloatToInt32(sx0 - 0.5f);
 698                 int ix1 = deCeilFloatToInt32(sx1 - 0.5f);
 699                 int iy0 = deCeilFloatToInt32(sy0 - 0.5f);
 700                 int iy1 = deCeilFloatToInt32(sy1 - 0.5f);
 701
 702                 int             v00 = (y * stride) + x;
 703                 int             v01 = (y * stride) + x + 1;
 704                 int             v10 = ((y + 1) * stride) + x;
 705                 int             v11 = ((y + 1) * stride) + x + 1;
 706                 Vec4    c00 = colors[v00];
 707                 Vec4    c01 = colors[v01];
 708                 Vec4    c10 = colors[v10];
 709                 Vec4    c11 = colors[v11];
 710
 711                 //printf("(%d,%d) -> (%f..%f, %f..%f) (%d..%d, %d..%d)\n", x, y, sx0, sx1, sy0, sy1, ix0, ix1, iy0, iy1);
 712
 713                 for (int iy = iy0; iy < iy1; iy++)
 714                 for (int ix = ix0; ix < ix1; ix++)
 715                 {
 716                         DE_ASSERT(deInBounds32(ix, 0, width));
 717                         DE_ASSERT(deInBounds32(iy, 0, height));
 718
 719                         float           sfx             = (float)ix + 0.5f;
 720                         float           sfy             = (float)iy + 0.5f;
 721                         float           fx1             = deFloatClamp((sfx - sx0) * oosx, 0.0f, 1.0f);
 722                         float           fy1             = deFloatClamp((sfy - sy0) * oosy, 0.0f, 1.0f);
 723
 724                         // Triangle quad interpolation.
 725                         bool            tri             = fx1 + fy1 <= 1.0f;
 726                         float           tx              = tri ? fx1 : (1.0f-fx1);
 727                         float           ty              = tri ? fy1 : (1.0f-fy1);
 728                         const Vec4&     t0              = tri ? c00 : c11;
 729                         const Vec4&     t1              = tri ? c01 : c10;
 730                         const Vec4&     t2              = tri ? c10 : c01;
 731                         Vec4            color   = t0 + (t1-t0)*tx + (t2-t0)*ty;
 732
 733                         result.setPixel(ix, iy, toRGBA(color));
 734                 }
 735         }
 736 }
 737
 738 void ShaderRenderCase::computeFragmentReference (Surface& result, const QuadGrid& quadGrid)
 739 {
 740         // Buffer info.
 741         int                                     width           = result.getWidth();
 742         int                                     height          = result.getHeight();
 743         bool                            hasAlpha        = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
 744         ShaderEvalContext       evalCtx         (quadGrid);
 745
 746         // Render.
 747         for (int y = 0; y < height; y++)
 748         for (int x = 0; x < width; x++)
 749         {
 750                 float sx = ((float)x + 0.5f) / (float)width;
 751                 float sy = ((float)y + 0.5f) / (float)height;
 752
 753                 evalCtx.reset(sx, sy);
 754                 m_evaluator.evaluate(evalCtx);
 755                 // Select either clear color or computed color based on discarded bit.
 756                 Vec4 color = evalCtx.isDiscarded ? m_clearColor : evalCtx.color;
 757
 758                 if (!hasAlpha)
 759                         color.w() = 1.0f;
 760
 761                 result.setPixel(x, y, toRGBA(color));
 762         }
 763 }
 764
 765 bool ShaderRenderCase::compareImages (const Surface& resImage, const Surface& refImage, float errorThreshold)
 766 {
 767         return tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", refImage, resImage, errorThreshold, tcu::COMPARE_LOG_RESULT);
 768 }
 769
 770 // Uniform name helpers.
 771
 772 const char* getIntUniformName (int number)
 773 {
 774         switch (number)
 775         {
 776                 case 0:         return "ui_zero";
 777                 case 1:         return "ui_one";
 778                 case 2:         return "ui_two";
 779                 case 3:         return "ui_three";
 780                 case 4:         return "ui_four";
 781                 case 5:         return "ui_five";
 782                 case 6:         return "ui_six";
 783                 case 7:         return "ui_seven";
 784                 case 8:         return "ui_eight";
 785                 case 101:       return "ui_oneHundredOne";
 786                 default:
 787                         DE_ASSERT(false);
 788                         return "";
 789         }
 790 }
 791
 792 const char* getFloatUniformName (int number)
 793 {
 794         switch (number)
 795         {
 796                 case 0: return "uf_zero";
 797                 case 1: return "uf_one";
 798                 case 2: return "uf_two";
 799                 case 3: return "uf_three";
 800                 case 4: return "uf_four";
 801                 case 5: return "uf_five";
 802                 case 6: return "uf_six";
 803                 case 7: return "uf_seven";
 804                 case 8: return "uf_eight";
 805                 default:
 806                         DE_ASSERT(false);
 807                         return "";
 808         }
 809 }
 810
 811 const char* getFloatFractionUniformName (int number)
 812 {
 813         switch (number)
 814         {
 815                 case 1: return "uf_one";
 816                 case 2: return "uf_half";
 817                 case 3: return "uf_third";
 818                 case 4: return "uf_fourth";
 819                 case 5: return "uf_fifth";
 820                 case 6: return "uf_sixth";
 821                 case 7: return "uf_seventh";
 822                 case 8: return "uf_eighth";
 823                 default:
 824                         DE_ASSERT(false);
 825                         return "";
 826         }
 827 }
 828
 829 void setupDefaultUniforms (const glu::RenderContext& context, deUint32 programID)
 830 {
 831         const glw::Functions& gl = context.getFunctions();
 832
 833         // Bool.
 834         struct BoolUniform { const char* name; bool value; };
 835         static const BoolUniform s_boolUniforms[] =
 836         {
 837                 { "ub_true",    true },
 838                 { "ub_false",   false },
 839         };
 840
 841         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_boolUniforms); i++)
 842         {
 843                 int uniLoc = gl.getUniformLocation(programID, s_boolUniforms[i].name);
 844                 if (uniLoc != -1)
 845                         gl.uniform1i(uniLoc, s_boolUniforms[i].value);
 846         }
 847
 848         // BVec4.
 849         struct BVec4Uniform { const char* name; BVec4 value; };
 850         static const BVec4Uniform s_bvec4Uniforms[] =
 851         {
 852                 { "ub4_true",   BVec4(true) },
 853                 { "ub4_false",  BVec4(false) },
 854         };
 855
 856         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_bvec4Uniforms); i++)
 857         {
 858                 const BVec4Uniform& uni = s_bvec4Uniforms[i];
 859                 int arr[4];
 860                 arr[0] = (int)uni.value.x();
 861                 arr[1] = (int)uni.value.y();
 862                 arr[2] = (int)uni.value.z();
 863                 arr[3] = (int)uni.value.w();
 864                 int uniLoc = gl.getUniformLocation(programID, uni.name);
 865                 if (uniLoc != -1)
 866                         gl.uniform4iv(uniLoc, 1, &arr[0]);
 867         }
 868
 869         // Int.
 870         struct IntUniform { const char* name; int value; };
 871         static const IntUniform s_intUniforms[] =
 872         {
 873                 { "ui_minusOne",                -1 },
 874                 { "ui_zero",                    0 },
 875                 { "ui_one",                             1 },
 876                 { "ui_two",                             2 },
 877                 { "ui_three",                   3 },
 878                 { "ui_four",                    4 },
 879                 { "ui_five",                    5 },
 880                 { "ui_six",                             6 },
 881                 { "ui_seven",                   7 },
 882                 { "ui_eight",                   8 },
 883                 { "ui_oneHundredOne",   101 }
 884         };
 885
 886         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_intUniforms); i++)
 887         {
 888                 int uniLoc = gl.getUniformLocation(programID, s_intUniforms[i].name);
 889                 if (uniLoc != -1)
 890                         gl.uniform1i(uniLoc, s_intUniforms[i].value);
 891         }
 892
 893         // IVec2.
 894         struct IVec2Uniform { const char* name; IVec2 value; };
 895         static const IVec2Uniform s_ivec2Uniforms[] =
 896         {
 897                 { "ui2_minusOne",       IVec2(-1) },
 898                 { "ui2_zero",           IVec2(0) },
 899                 { "ui2_one",            IVec2(1) },
 900                 { "ui2_two",            IVec2(2) },
 901                 { "ui2_four",           IVec2(4) },
 902                 { "ui2_five",           IVec2(5) }
 903         };
 904
 905         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec2Uniforms); i++)
 906         {
 907                 int uniLoc = gl.getUniformLocation(programID, s_ivec2Uniforms[i].name);
 908                 if (uniLoc != -1)
 909                         gl.uniform2iv(uniLoc, 1, s_ivec2Uniforms[i].value.getPtr());
 910         }
 911
 912         // IVec3.
 913         struct IVec3Uniform { const char* name; IVec3 value; };
 914         static const IVec3Uniform s_ivec3Uniforms[] =
 915         {
 916                 { "ui3_minusOne",       IVec3(-1) },
 917                 { "ui3_zero",           IVec3(0) },
 918                 { "ui3_one",            IVec3(1) },
 919                 { "ui3_two",            IVec3(2) },
 920                 { "ui3_four",           IVec3(4) },
 921                 { "ui3_five",           IVec3(5) }
 922         };
 923
 924         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec3Uniforms); i++)
 925         {
 926                 int uniLoc = gl.getUniformLocation(programID, s_ivec3Uniforms[i].name);
 927                 if (uniLoc != -1)
 928                         gl.uniform3iv(uniLoc, 1, s_ivec3Uniforms[i].value.getPtr());
 929         }
 930
 931         // IVec4.
 932         struct IVec4Uniform { const char* name; IVec4 value; };
 933         static const IVec4Uniform s_ivec4Uniforms[] =
 934         {
 935                 { "ui4_minusOne",       IVec4(-1) },
 936                 { "ui4_zero",           IVec4(0) },
 937                 { "ui4_one",            IVec4(1) },
 938                 { "ui4_two",            IVec4(2) },
 939                 { "ui4_four",           IVec4(4) },
 940                 { "ui4_five",           IVec4(5) }
 941         };
 942
 943         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec4Uniforms); i++)
 944         {
 945                 int uniLoc = gl.getUniformLocation(programID, s_ivec4Uniforms[i].name);
 946                 if (uniLoc != -1)
 947                         gl.uniform4iv(uniLoc, 1, s_ivec4Uniforms[i].value.getPtr());
 948         }
 949
 950         // Float.
 951         struct FloatUniform { const char* name; float value; };
 952         static const FloatUniform s_floatUniforms[] =
 953         {
 954                 { "uf_zero",    0.0f },
 955                 { "uf_one",             1.0f },
 956                 { "uf_two",             2.0f },
 957                 { "uf_three",   3.0f },
 958                 { "uf_four",    4.0f },
 959                 { "uf_five",    5.0f },
 960                 { "uf_six",             6.0f },
 961                 { "uf_seven",   7.0f },
 962                 { "uf_eight",   8.0f },
 963                 { "uf_half",    1.0f / 2.0f },
 964                 { "uf_third",   1.0f / 3.0f },
 965                 { "uf_fourth",  1.0f / 4.0f },
 966                 { "uf_fifth",   1.0f / 5.0f },
 967                 { "uf_sixth",   1.0f / 6.0f },
 968                 { "uf_seventh", 1.0f / 7.0f },
 969                 { "uf_eighth",  1.0f / 8.0f }
 970         };
 971
 972         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_floatUniforms); i++)
 973         {
 974                 int uniLoc = gl.getUniformLocation(programID, s_floatUniforms[i].name);
 975                 if (uniLoc != -1)
 976                         gl.uniform1f(uniLoc, s_floatUniforms[i].value);
 977         }
 978
 979         // Vec2.
 980         struct Vec2Uniform { const char* name; Vec2 value; };
 981         static const Vec2Uniform s_vec2Uniforms[] =
 982         {
 983                 { "uv2_minusOne",       Vec2(-1.0f) },
 984                 { "uv2_zero",           Vec2(0.0f) },
 985                 { "uv2_half",           Vec2(0.5f) },
 986                 { "uv2_one",            Vec2(1.0f) },
 987                 { "uv2_two",            Vec2(2.0f) },
 988         };
 989
 990         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec2Uniforms); i++)
 991         {
 992                 int uniLoc = gl.getUniformLocation(programID, s_vec2Uniforms[i].name);
 993                 if (uniLoc != -1)
 994                         gl.uniform2fv(uniLoc, 1, s_vec2Uniforms[i].value.getPtr());
 995         }
 996
 997         // Vec3.
 998         struct Vec3Uniform { const char* name; Vec3 value; };
 999         static const Vec3Uniform s_vec3Uniforms[] =
1000         {
1001                 { "uv3_minusOne",       Vec3(-1.0f) },
1002                 { "uv3_zero",           Vec3(0.0f) },
1003                 { "uv3_half",           Vec3(0.5f) },
1004                 { "uv3_one",            Vec3(1.0f) },
1005                 { "uv3_two",            Vec3(2.0f) },
1006         };
1007
1008         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec3Uniforms); i++)
1009         {
1010                 int uniLoc = gl.getUniformLocation(programID, s_vec3Uniforms[i].name);
1011                 if (uniLoc != -1)
1012                         gl.uniform3fv(uniLoc, 1, s_vec3Uniforms[i].value.getPtr());
1013         }
1014
1015         // Vec4.
1016         struct Vec4Uniform { const char* name; Vec4 value; };
1017         static const Vec4Uniform s_vec4Uniforms[] =
1018         {
1019                 { "uv4_minusOne",       Vec4(-1.0f) },
1020                 { "uv4_zero",           Vec4(0.0f) },
1021                 { "uv4_half",           Vec4(0.5f) },
1022                 { "uv4_one",            Vec4(1.0f) },
1023                 { "uv4_two",            Vec4(2.0f) },
1024                 { "uv4_black",          Vec4(0.0f, 0.0f, 0.0f, 1.0f) },
1025                 { "uv4_gray",           Vec4(0.5f, 0.5f, 0.5f, 1.0f) },
1026                 { "uv4_white",          Vec4(1.0f, 1.0f, 1.0f, 1.0f) },
1027         };
1028
1029         for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec4Uniforms); i++)
1030         {
1031                 int uniLoc = gl.getUniformLocation(programID, s_vec4Uniforms[i].name);
1032                 if (uniLoc != -1)
1033                         gl.uniform4fv(uniLoc, 1, s_vec4Uniforms[i].value.getPtr());
1034         }
1035 }
1036
1037 } // gls
1038 } // deqp