external/openglcts/modules/common/glcShaderLibraryCase.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2016 Google Inc.
   6  * Copyright (c) 2016 The Khronos Group Inc.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */ /*!
  21  * \file
  22  * \brief Compiler test case.
  23  */ /*-------------------------------------------------------------------*/
  24
  25 #include "glcShaderLibraryCase.hpp"
  26
  27 #include "tcuRenderTarget.hpp"
  28 #include "tcuTestLog.hpp"
  29
  30 #include "gluDrawUtil.hpp"
  31 #include "gluPixelTransfer.hpp"
  32 #include "gluShaderProgram.hpp"
  33 #include "tcuStringTemplate.hpp"
  34
  35 #include "glwEnums.hpp"
  36 #include "glwFunctions.hpp"
  37
  38 #include "deInt32.h"
  39 #include "deMath.h"
  40 #include "deRandom.hpp"
  41 #include "deString.h"
  42
  43 #include <map>
  44 #include <sstream>
  45 #include <string>
  46 #include <vector>
  47
  48 using namespace std;
  49 using namespace tcu;
  50 using namespace glu;
  51
  52 namespace deqp
  53 {
  54 namespace sl
  55 {
  56
  57 enum
  58 {
  59         VIEWPORT_WIDTH  = 128,
  60         VIEWPORT_HEIGHT = 128
  61 };
  62
  63 static inline bool usesShaderInoutQualifiers(glu::GLSLVersion version)
  64 {
  65         switch (version)
  66         {
  67         case glu::GLSL_VERSION_100_ES:
  68         case glu::GLSL_VERSION_130:
  69         case glu::GLSL_VERSION_140:
  70         case glu::GLSL_VERSION_150:
  71                 return false;
  72
  73         default:
  74                 return true;
  75         }
  76 }
  77
  78 // ShaderCase.
  79
  80 ShaderCase::ShaderCase(tcu::TestContext& testCtx, RenderContext& renderCtx, const char* name, const char* description,
  81                                            ExpectResult expectResult, const std::vector<ValueBlock>& valueBlocks, GLSLVersion targetVersion,
  82                                            const char* vertexSource, const char* fragmentSource)
  83         : tcu::TestCase(testCtx, name, description)
  84         , m_renderCtx(renderCtx)
  85         , m_expectResult(expectResult)
  86         , m_valueBlocks(valueBlocks)
  87         , m_targetVersion(targetVersion)
  88 {
  89         // If no value blocks given, use an empty one.
  90         if (m_valueBlocks.size() == 0)
  91                 m_valueBlocks.push_back(ValueBlock());
  92
  93         // Use first value block to specialize shaders.
  94         const ValueBlock& valueBlock = m_valueBlocks[0];
  95
  96         // \todo [2010-04-01 petri] Check that all value blocks have matching values.
  97
  98         // Generate specialized shader sources.
  99         if (vertexSource && fragmentSource)
 100         {
 101                 m_caseType = CASETYPE_COMPLETE;
 102                 specializeShaders(vertexSource, fragmentSource, m_vertexSource, m_fragmentSource, valueBlock);
 103         }
 104         else if (vertexSource)
 105         {
 106                 m_caseType               = CASETYPE_VERTEX_ONLY;
 107                 m_vertexSource   = specializeVertexShader(vertexSource, valueBlock);
 108                 m_fragmentSource = genFragmentShader(valueBlock);
 109         }
 110         else
 111         {
 112                 DE_ASSERT(fragmentSource);
 113                 m_caseType               = CASETYPE_FRAGMENT_ONLY;
 114                 m_vertexSource   = genVertexShader(valueBlock);
 115                 m_fragmentSource = specializeFragmentShader(fragmentSource, valueBlock);
 116         }
 117 }
 118
 119 ShaderCase::~ShaderCase(void)
 120 {
 121 }
 122
 123 static void setUniformValue(const glw::Functions& gl, deUint32 programID, const std::string& name,
 124                                                         const ShaderCase::Value& val, int arrayNdx)
 125 {
 126         int scalarSize = getDataTypeScalarSize(val.dataType);
 127         int loc            = gl.getUniformLocation(programID, name.c_str());
 128
 129         TCU_CHECK_MSG(loc != -1, "uniform location not found");
 130
 131         DE_STATIC_ASSERT(sizeof(ShaderCase::Value::Element) == sizeof(glw::GLfloat));
 132         DE_STATIC_ASSERT(sizeof(ShaderCase::Value::Element) == sizeof(glw::GLint));
 133
 134         int elemNdx = (val.arrayLength == 1) ? 0 : (arrayNdx * scalarSize);
 135
 136         switch (val.dataType)
 137         {
 138         case TYPE_FLOAT:
 139                 gl.uniform1fv(loc, 1, &val.elements[elemNdx].float32);
 140                 break;
 141         case TYPE_FLOAT_VEC2:
 142                 gl.uniform2fv(loc, 1, &val.elements[elemNdx].float32);
 143                 break;
 144         case TYPE_FLOAT_VEC3:
 145                 gl.uniform3fv(loc, 1, &val.elements[elemNdx].float32);
 146                 break;
 147         case TYPE_FLOAT_VEC4:
 148                 gl.uniform4fv(loc, 1, &val.elements[elemNdx].float32);
 149                 break;
 150         case TYPE_FLOAT_MAT2:
 151                 gl.uniformMatrix2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 152                 break;
 153         case TYPE_FLOAT_MAT3:
 154                 gl.uniformMatrix3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 155                 break;
 156         case TYPE_FLOAT_MAT4:
 157                 gl.uniformMatrix4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 158                 break;
 159         case TYPE_INT:
 160                 gl.uniform1iv(loc, 1, &val.elements[elemNdx].int32);
 161                 break;
 162         case TYPE_INT_VEC2:
 163                 gl.uniform2iv(loc, 1, &val.elements[elemNdx].int32);
 164                 break;
 165         case TYPE_INT_VEC3:
 166                 gl.uniform3iv(loc, 1, &val.elements[elemNdx].int32);
 167                 break;
 168         case TYPE_INT_VEC4:
 169                 gl.uniform4iv(loc, 1, &val.elements[elemNdx].int32);
 170                 break;
 171         case TYPE_BOOL:
 172                 gl.uniform1iv(loc, 1, &val.elements[elemNdx].int32);
 173                 break;
 174         case TYPE_BOOL_VEC2:
 175                 gl.uniform2iv(loc, 1, &val.elements[elemNdx].int32);
 176                 break;
 177         case TYPE_BOOL_VEC3:
 178                 gl.uniform3iv(loc, 1, &val.elements[elemNdx].int32);
 179                 break;
 180         case TYPE_BOOL_VEC4:
 181                 gl.uniform4iv(loc, 1, &val.elements[elemNdx].int32);
 182                 break;
 183         case TYPE_UINT:
 184                 gl.uniform1uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32);
 185                 break;
 186         case TYPE_UINT_VEC2:
 187                 gl.uniform2uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32);
 188                 break;
 189         case TYPE_UINT_VEC3:
 190                 gl.uniform3uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32);
 191                 break;
 192         case TYPE_UINT_VEC4:
 193                 gl.uniform4uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32);
 194                 break;
 195         case TYPE_FLOAT_MAT2X3:
 196                 gl.uniformMatrix2x3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 197                 break;
 198         case TYPE_FLOAT_MAT2X4:
 199                 gl.uniformMatrix2x4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 200                 break;
 201         case TYPE_FLOAT_MAT3X2:
 202                 gl.uniformMatrix3x2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 203                 break;
 204         case TYPE_FLOAT_MAT3X4:
 205                 gl.uniformMatrix3x4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 206                 break;
 207         case TYPE_FLOAT_MAT4X2:
 208                 gl.uniformMatrix4x2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 209                 break;
 210         case TYPE_FLOAT_MAT4X3:
 211                 gl.uniformMatrix4x3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32);
 212                 break;
 213
 214         case TYPE_SAMPLER_2D:
 215         case TYPE_SAMPLER_CUBE:
 216                 DE_ASSERT(DE_FALSE && "implement!");
 217                 break;
 218
 219         default:
 220                 DE_ASSERT(false);
 221         }
 222 }
 223
 224 bool ShaderCase::checkPixels(Surface& surface, int minX, int maxX, int minY, int maxY)
 225 {
 226         TestLog& log               = m_testCtx.getLog();
 227         bool     allWhite         = true;
 228         bool     allBlack         = true;
 229         bool     anyUnexpected = false;
 230
 231         DE_ASSERT((maxX > minX) && (maxY > minY));
 232
 233         for (int y = minY; y <= maxY; y++)
 234         {
 235                 for (int x = minX; x <= maxX; x++)
 236                 {
 237                         RGBA pixel = surface.getPixel(x, y);
 238                         // Note: we really do not want to involve alpha in the check comparison
 239                         // \todo [2010-09-22 kalle] Do we know that alpha would be one? If yes, could use color constants white and black.
 240                         bool isWhite = (pixel.getRed() == 255) && (pixel.getGreen() == 255) && (pixel.getBlue() == 255);
 241                         bool isBlack = (pixel.getRed() == 0) && (pixel.getGreen() == 0) && (pixel.getBlue() == 0);
 242
 243                         allWhite          = allWhite && isWhite;
 244                         allBlack          = allBlack && isBlack;
 245                         anyUnexpected = anyUnexpected || (!isWhite && !isBlack);
 246                 }
 247         }
 248
 249         if (!allWhite)
 250         {
 251                 if (anyUnexpected)
 252                         log << TestLog::Message
 253                                 << "WARNING: expecting all rendered pixels to be white or black, but got other colors as well!"
 254                                 << TestLog::EndMessage;
 255                 else if (!allBlack)
 256                         log << TestLog::Message
 257                                 << "WARNING: got inconsistent results over the image, when all pixels should be the same color!"
 258                                 << TestLog::EndMessage;
 259
 260                 return false;
 261         }
 262         return true;
 263 }
 264
 265 bool ShaderCase::execute(void)
 266 {
 267         TestLog&                          log = m_testCtx.getLog();
 268         const glw::Functions& gl  = m_renderCtx.getFunctions();
 269
 270         // Compute viewport.
 271         const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget();
 272         de::Random                               rnd(deStringHash(getName()));
 273         int                                              width                          = deMin32(renderTarget.getWidth(), VIEWPORT_WIDTH);
 274         int                                              height                         = deMin32(renderTarget.getHeight(), VIEWPORT_HEIGHT);
 275         int                                              viewportX                      = rnd.getInt(0, renderTarget.getWidth() - width);
 276         int                                              viewportY                      = rnd.getInt(0, renderTarget.getHeight() - height);
 277         const int                                numVerticesPerDraw = 4;
 278
 279         GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderCase::execute(): start");
 280
 281         // Setup viewport.
 282         gl.viewport(viewportX, viewportY, width, height);
 283
 284         const float                quadSize                       = 1.0f;
 285         static const float s_positions[4 * 4] = { -quadSize, -quadSize, 0.0f, 1.0f, -quadSize, +quadSize, 0.0f, 1.0f,
 286                                                                                           +quadSize, -quadSize, 0.0f, 1.0f, +quadSize, +quadSize, 0.0f, 1.0f };
 287
 288         static const deUint16 s_indices[2 * 3] = { 0, 1, 2, 1, 3, 2 };
 289
 290         // Setup program.
 291         glu::ShaderProgram program(m_renderCtx, glu::makeVtxFragSources(m_vertexSource.c_str(), m_fragmentSource.c_str()));
 292
 293         // Check that compile/link results are what we expect.
 294         bool            vertexOk   = program.getShaderInfo(SHADERTYPE_VERTEX).compileOk;
 295         bool            fragmentOk = program.getShaderInfo(SHADERTYPE_FRAGMENT).compileOk;
 296         bool            linkOk   = program.getProgramInfo().linkOk;
 297         const char* failReason = DE_NULL;
 298
 299         log << program;
 300
 301         switch (m_expectResult)
 302         {
 303         case EXPECT_PASS:
 304                 if (!vertexOk || !fragmentOk)
 305                         failReason = "expected shaders to compile and link properly, but failed to compile.";
 306                 else if (!linkOk)
 307                         failReason = "expected shaders to compile and link properly, but failed to link.";
 308                 break;
 309
 310         case EXPECT_COMPILE_FAIL:
 311                 if (vertexOk && fragmentOk && !linkOk)
 312                         failReason = "expected compilation to fail, but both shaders compiled and link failed.";
 313                 else if (vertexOk && fragmentOk)
 314                         failReason = "expected compilation to fail, but both shaders compiled correctly.";
 315                 break;
 316
 317         case EXPECT_LINK_FAIL:
 318                 if (!vertexOk || !fragmentOk)
 319                         failReason = "expected linking to fail, but unable to compile.";
 320                 else if (linkOk)
 321                         failReason = "expected linking to fail, but passed.";
 322                 break;
 323
 324         default:
 325                 DE_ASSERT(false);
 326                 return false;
 327         }
 328
 329         if (failReason != DE_NULL)
 330         {
 331                 // \todo [2010-06-07 petri] These should be handled in the test case?
 332                 log << TestLog::Message << "ERROR: " << failReason << TestLog::EndMessage;
 333
 334                 // If implementation parses shader at link time, report it as quality warning.
 335                 if (m_expectResult == EXPECT_COMPILE_FAIL && vertexOk && fragmentOk && !linkOk)
 336                         m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, failReason);
 337                 else
 338                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, failReason);
 339                 return false;
 340         }
 341
 342         // Return if compile/link expected to fail.
 343         if (m_expectResult != EXPECT_PASS)
 344                 return (failReason == DE_NULL);
 345
 346         // Start using program.
 347         deUint32 programID = program.getProgram();
 348         gl.useProgram(programID);
 349         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()");
 350
 351         // Fetch location for positions positions.
 352         int positionLoc = gl.getAttribLocation(programID, "dEQP_Position");
 353         if (positionLoc == -1)
 354         {
 355                 string errStr = string("no location found for attribute 'dEQP_Position'");
 356                 TCU_FAIL(errStr.c_str());
 357         }
 358
 359         // Iterate all value blocks.
 360         for (int blockNdx = 0; blockNdx < (int)m_valueBlocks.size(); blockNdx++)
 361         {
 362                 const ValueBlock& valueBlock = m_valueBlocks[blockNdx];
 363
 364                 // Iterate all array sub-cases.
 365                 for (int arrayNdx = 0; arrayNdx < valueBlock.arrayLength; arrayNdx++)
 366                 {
 367                         int                                                numValues = (int)valueBlock.values.size();
 368                         vector<VertexArrayBinding> vertexArrays;
 369
 370                         int                                        attribValueNdx = 0;
 371                         vector<vector<float> > attribValues(numValues);
 372
 373                         vertexArrays.push_back(va::Float(positionLoc, 4, numVerticesPerDraw, 0, &s_positions[0]));
 374
 375                         // Collect VA pointer for inputs and set uniform values for outputs (refs).
 376                         for (int valNdx = 0; valNdx < numValues; valNdx++)
 377                         {
 378                                 const ShaderCase::Value& val            = valueBlock.values[valNdx];
 379                                 const char*                              valueName  = val.valueName.c_str();
 380                                 DataType                                 dataType   = val.dataType;
 381                                 int                                              scalarSize = getDataTypeScalarSize(val.dataType);
 382
 383                                 GLU_EXPECT_NO_ERROR(gl.getError(), "before set uniforms");
 384
 385                                 if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 386                                 {
 387                                         // Replicate values four times.
 388                                         std::vector<float>& scalars = attribValues[attribValueNdx++];
 389                                         scalars.resize(numVerticesPerDraw * scalarSize);
 390                                         if (isDataTypeFloatOrVec(dataType) || isDataTypeMatrix(dataType))
 391                                         {
 392                                                 for (int repNdx = 0; repNdx < numVerticesPerDraw; repNdx++)
 393                                                         for (int ndx                                               = 0; ndx < scalarSize; ndx++)
 394                                                                 scalars[repNdx * scalarSize + ndx] = val.elements[arrayNdx * scalarSize + ndx].float32;
 395                                         }
 396                                         else
 397                                         {
 398                                                 // convert to floats.
 399                                                 for (int repNdx = 0; repNdx < numVerticesPerDraw; repNdx++)
 400                                                 {
 401                                                         for (int ndx = 0; ndx < scalarSize; ndx++)
 402                                                         {
 403                                                                 float v = (float)val.elements[arrayNdx * scalarSize + ndx].int32;
 404                                                                 DE_ASSERT(val.elements[arrayNdx * scalarSize + ndx].int32 == (int)v);
 405                                                                 scalars[repNdx * scalarSize + ndx] = v;
 406                                                         }
 407                                                 }
 408                                         }
 409
 410                                         // Attribute name prefix.
 411                                         string attribPrefix = "";
 412                                         // \todo [2010-05-27 petri] Should latter condition only apply for vertex cases (or actually non-fragment cases)?
 413                                         if ((m_caseType == CASETYPE_FRAGMENT_ONLY) || (getDataTypeScalarType(dataType) != TYPE_FLOAT))
 414                                                 attribPrefix = "a_";
 415
 416                                         // Input always given as attribute.
 417                                         string attribName = attribPrefix + valueName;
 418                                         int     attribLoc  = gl.getAttribLocation(programID, attribName.c_str());
 419                                         if (attribLoc == -1)
 420                                         {
 421                                                 log << TestLog::Message << "Warning: no location found for attribute '" << attribName << "'"
 422                                                         << TestLog::EndMessage;
 423                                                 continue;
 424                                         }
 425
 426                                         if (isDataTypeMatrix(dataType))
 427                                         {
 428                                                 int numCols = getDataTypeMatrixNumColumns(dataType);
 429                                                 int numRows = getDataTypeMatrixNumRows(dataType);
 430                                                 DE_ASSERT(scalarSize == numCols * numRows);
 431
 432                                                 for (int i = 0; i < numCols; i++)
 433                                                         vertexArrays.push_back(va::Float(attribLoc + i, numRows, numVerticesPerDraw,
 434                                                                                                                          static_cast<int>(scalarSize * sizeof(float)),
 435                                                                                                                          &scalars[i * numRows]));
 436                                         }
 437                                         else
 438                                         {
 439                                                 DE_ASSERT(isDataTypeFloatOrVec(dataType) || isDataTypeIntOrIVec(dataType) ||
 440                                                                   isDataTypeUintOrUVec(dataType) || isDataTypeBoolOrBVec(dataType));
 441                                                 vertexArrays.push_back(va::Float(attribLoc, scalarSize, numVerticesPerDraw, 0, &scalars[0]));
 442                                         }
 443
 444                                         GLU_EXPECT_NO_ERROR(gl.getError(), "set vertex attrib array");
 445                                 }
 446                                 else if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 447                                 {
 448                                         // Set reference value.
 449                                         string refName = string("ref_") + valueName;
 450                                         setUniformValue(gl, programID, refName, val, arrayNdx);
 451                                         GLU_EXPECT_NO_ERROR(gl.getError(), "set reference uniforms");
 452                                 }
 453                                 else
 454                                 {
 455                                         DE_ASSERT(val.storageType == ShaderCase::Value::STORAGE_UNIFORM);
 456                                         setUniformValue(gl, programID, valueName, val, arrayNdx);
 457                                         GLU_EXPECT_NO_ERROR(gl.getError(), "set uniforms");
 458                                 }
 459                         }
 460
 461                         // Clear.
 462                         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 463                         gl.clear(GL_COLOR_BUFFER_BIT);
 464                         GLU_EXPECT_NO_ERROR(gl.getError(), "clear buffer");
 465
 466                         // Draw.
 467                         draw(m_renderCtx, program.getProgram(), (int)vertexArrays.size(), &vertexArrays[0],
 468                                  pr::Triangles(DE_LENGTH_OF_ARRAY(s_indices), &s_indices[0]));
 469                         GLU_EXPECT_NO_ERROR(gl.getError(), "draw");
 470
 471                         // Read back results.
 472                         Surface surface(width, height);
 473                         glu::readPixels(m_renderCtx, viewportX, viewportY, surface.getAccess());
 474                         GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
 475
 476                         float w = s_positions[3];
 477                         int   minY = deCeilFloatToInt32(((-quadSize / w) * 0.5f + 0.5f) * (float)height + 1.0f);
 478                         int   maxY = deFloorFloatToInt32(((+quadSize / w) * 0.5f + 0.5f) * (float)height - 0.5f);
 479                         int   minX = deCeilFloatToInt32(((-quadSize / w) * 0.5f + 0.5f) * (float)width + 1.0f);
 480                         int   maxX = deFloorFloatToInt32(((+quadSize / w) * 0.5f + 0.5f) * (float)width - 0.5f);
 481
 482                         if (!checkPixels(surface, minX, maxX, minY, maxY))
 483                         {
 484                                 log << TestLog::Message << "INCORRECT RESULT for (value block " << (blockNdx + 1) << " of "
 485                                         << (int)m_valueBlocks.size() << ", sub-case " << arrayNdx + 1 << " of " << valueBlock.arrayLength
 486                                         << "):" << TestLog::EndMessage;
 487
 488                                 log << TestLog::Message << "Failing shader input/output values:" << TestLog::EndMessage;
 489                                 dumpValues(valueBlock, arrayNdx);
 490
 491                                 // Dump image on failure.
 492                                 log << TestLog::Image("Result", "Rendered result image", surface);
 493
 494                                 gl.useProgram(0);
 495                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
 496                                 return false;
 497                         }
 498                 }
 499         }
 500
 501         gl.useProgram(0);
 502         GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderCase::execute(): end");
 503         return true;
 504 }
 505
 506 TestCase::IterateResult ShaderCase::iterate(void)
 507 {
 508         // Initialize state to pass.
 509         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 510
 511         bool executeOk = execute();
 512
 513         DE_ASSERT(executeOk ? m_testCtx.getTestResult() == QP_TEST_RESULT_PASS :
 514                                                   m_testCtx.getTestResult() != QP_TEST_RESULT_PASS);
 515         (void)executeOk;
 516         return TestCase::STOP;
 517 }
 518
 519 // This functions builds a matching vertex shader for a 'both' case, when
 520 // the fragment shader is being tested.
 521 // We need to build attributes and varyings for each 'input'.
 522 string ShaderCase::genVertexShader(const ValueBlock& valueBlock)
 523 {
 524         ostringstream res;
 525         const bool      usesInout = usesShaderInoutQualifiers(m_targetVersion);
 526         const char*   vtxIn             = usesInout ? "in" : "attribute";
 527         const char*   vtxOut    = usesInout ? "out" : "varying";
 528
 529         res << glu::getGLSLVersionDeclaration(m_targetVersion) << "\n";
 530
 531         // Declarations (position + attribute/varying for each input).
 532         res << "precision highp float;\n";
 533         res << "precision highp int;\n";
 534         res << "\n";
 535         res << vtxIn << " highp vec4 dEQP_Position;\n";
 536         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 537         {
 538                 const ShaderCase::Value& val = valueBlock.values[ndx];
 539                 if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 540                 {
 541                         DataType        floatType = getDataTypeFloatScalars(val.dataType);
 542                         const char* typeStr   = getDataTypeName(floatType);
 543                         res << vtxIn << " " << typeStr << " a_" << val.valueName << ";\n";
 544
 545                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 546                                 res << vtxOut << " " << typeStr << " " << val.valueName << ";\n";
 547                         else
 548                                 res << vtxOut << " " << typeStr << " v_" << val.valueName << ";\n";
 549                 }
 550         }
 551         res << "\n";
 552
 553         // Main function.
 554         // - gl_Position = dEQP_Position;
 555         // - for each input: write attribute directly to varying
 556         res << "void main()\n";
 557         res << "{\n";
 558         res << "    gl_Position = dEQP_Position;\n";
 559         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 560         {
 561                 const ShaderCase::Value& val = valueBlock.values[ndx];
 562                 if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 563                 {
 564                         const string& name = val.valueName;
 565                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 566                                 res << "    " << name << " = a_" << name << ";\n";
 567                         else
 568                                 res << "    v_" << name << " = a_" << name << ";\n";
 569                 }
 570         }
 571
 572         res << "}\n";
 573         return res.str();
 574 }
 575
 576 static void genCompareFunctions(ostringstream& stream, const ShaderCase::ValueBlock& valueBlock, bool useFloatTypes)
 577 {
 578         bool cmpTypeFound[TYPE_LAST];
 579         for (int i                      = 0; i < TYPE_LAST; i++)
 580                 cmpTypeFound[i] = false;
 581
 582         for (int valueNdx = 0; valueNdx < (int)valueBlock.values.size(); valueNdx++)
 583         {
 584                 const ShaderCase::Value& val = valueBlock.values[valueNdx];
 585                 if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 586                         cmpTypeFound[(int)val.dataType] = true;
 587         }
 588
 589         if (useFloatTypes)
 590         {
 591                 if (cmpTypeFound[TYPE_BOOL])
 592                         stream << "bool isOk (float a, bool b) { return ((a > 0.5) == b); }\n";
 593                 if (cmpTypeFound[TYPE_BOOL_VEC2])
 594                         stream << "bool isOk (vec2 a, bvec2 b) { return (greaterThan(a, vec2(0.5)) == b); }\n";
 595                 if (cmpTypeFound[TYPE_BOOL_VEC3])
 596                         stream << "bool isOk (vec3 a, bvec3 b) { return (greaterThan(a, vec3(0.5)) == b); }\n";
 597                 if (cmpTypeFound[TYPE_BOOL_VEC4])
 598                         stream << "bool isOk (vec4 a, bvec4 b) { return (greaterThan(a, vec4(0.5)) == b); }\n";
 599                 if (cmpTypeFound[TYPE_INT])
 600                         stream << "bool isOk (float a, int b)  { float atemp = a+0.5; return (float(b) <= atemp && atemp <= "
 601                                           "float(b+1)); }\n";
 602                 if (cmpTypeFound[TYPE_INT_VEC2])
 603                         stream << "bool isOk (vec2 a, ivec2 b) { return (ivec2(floor(a + 0.5)) == b); }\n";
 604                 if (cmpTypeFound[TYPE_INT_VEC3])
 605                         stream << "bool isOk (vec3 a, ivec3 b) { return (ivec3(floor(a + 0.5)) == b); }\n";
 606                 if (cmpTypeFound[TYPE_INT_VEC4])
 607                         stream << "bool isOk (vec4 a, ivec4 b) { return (ivec4(floor(a + 0.5)) == b); }\n";
 608                 if (cmpTypeFound[TYPE_UINT])
 609                         stream << "bool isOk (float a, uint b) { float atemp = a+0.5; return (float(b) <= atemp && atemp <= "
 610                                           "float(b+1)); }\n";
 611                 if (cmpTypeFound[TYPE_UINT_VEC2])
 612                         stream << "bool isOk (vec2 a, uvec2 b) { return (uvec2(floor(a + 0.5)) == b); }\n";
 613                 if (cmpTypeFound[TYPE_UINT_VEC3])
 614                         stream << "bool isOk (vec3 a, uvec3 b) { return (uvec3(floor(a + 0.5)) == b); }\n";
 615                 if (cmpTypeFound[TYPE_UINT_VEC4])
 616                         stream << "bool isOk (vec4 a, uvec4 b) { return (uvec4(floor(a + 0.5)) == b); }\n";
 617         }
 618         else
 619         {
 620                 if (cmpTypeFound[TYPE_BOOL])
 621                         stream << "bool isOk (bool a, bool b)   { return (a == b); }\n";
 622                 if (cmpTypeFound[TYPE_BOOL_VEC2])
 623                         stream << "bool isOk (bvec2 a, bvec2 b) { return (a == b); }\n";
 624                 if (cmpTypeFound[TYPE_BOOL_VEC3])
 625                         stream << "bool isOk (bvec3 a, bvec3 b) { return (a == b); }\n";
 626                 if (cmpTypeFound[TYPE_BOOL_VEC4])
 627                         stream << "bool isOk (bvec4 a, bvec4 b) { return (a == b); }\n";
 628                 if (cmpTypeFound[TYPE_INT])
 629                         stream << "bool isOk (int a, int b)     { return (a == b); }\n";
 630                 if (cmpTypeFound[TYPE_INT_VEC2])
 631                         stream << "bool isOk (ivec2 a, ivec2 b) { return (a == b); }\n";
 632                 if (cmpTypeFound[TYPE_INT_VEC3])
 633                         stream << "bool isOk (ivec3 a, ivec3 b) { return (a == b); }\n";
 634                 if (cmpTypeFound[TYPE_INT_VEC4])
 635                         stream << "bool isOk (ivec4 a, ivec4 b) { return (a == b); }\n";
 636                 if (cmpTypeFound[TYPE_UINT])
 637                         stream << "bool isOk (uint a, uint b)   { return (a == b); }\n";
 638                 if (cmpTypeFound[TYPE_UINT_VEC2])
 639                         stream << "bool isOk (uvec2 a, uvec2 b) { return (a == b); }\n";
 640                 if (cmpTypeFound[TYPE_UINT_VEC3])
 641                         stream << "bool isOk (uvec3 a, uvec3 b) { return (a == b); }\n";
 642                 if (cmpTypeFound[TYPE_UINT_VEC4])
 643                         stream << "bool isOk (uvec4 a, uvec4 b) { return (a == b); }\n";
 644         }
 645
 646         if (cmpTypeFound[TYPE_FLOAT])
 647                 stream << "bool isOk (float a, float b, float eps) { return (abs(a-b) <= (eps*abs(b) + eps)); }\n";
 648         if (cmpTypeFound[TYPE_FLOAT_VEC2])
 649                 stream
 650                         << "bool isOk (vec2 a, vec2 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
 651         if (cmpTypeFound[TYPE_FLOAT_VEC3])
 652                 stream
 653                         << "bool isOk (vec3 a, vec3 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
 654         if (cmpTypeFound[TYPE_FLOAT_VEC4])
 655                 stream
 656                         << "bool isOk (vec4 a, vec4 b, float eps) { return all(lessThanEqual(abs(a-b), (eps*abs(b) + eps))); }\n";
 657
 658         if (cmpTypeFound[TYPE_FLOAT_MAT2])
 659                 stream << "bool isOk (mat2 a, mat2 b, float eps) { vec2 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return "
 660                                   "all(lessThanEqual(diff, vec2(eps))); }\n";
 661         if (cmpTypeFound[TYPE_FLOAT_MAT2X3])
 662                 stream << "bool isOk (mat2x3 a, mat2x3 b, float eps) { vec3 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return "
 663                                   "all(lessThanEqual(diff, vec3(eps))); }\n";
 664         if (cmpTypeFound[TYPE_FLOAT_MAT2X4])
 665                 stream << "bool isOk (mat2x4 a, mat2x4 b, float eps) { vec4 diff = max(abs(a[0]-b[0]), abs(a[1]-b[1])); return "
 666                                   "all(lessThanEqual(diff, vec4(eps))); }\n";
 667         if (cmpTypeFound[TYPE_FLOAT_MAT3X2])
 668                 stream << "bool isOk (mat3x2 a, mat3x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 669                                   "abs(a[2]-b[2])); return all(lessThanEqual(diff, vec2(eps))); }\n";
 670         if (cmpTypeFound[TYPE_FLOAT_MAT3])
 671                 stream << "bool isOk (mat3 a, mat3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 672                                   "abs(a[2]-b[2])); return all(lessThanEqual(diff, vec3(eps))); }\n";
 673         if (cmpTypeFound[TYPE_FLOAT_MAT3X4])
 674                 stream << "bool isOk (mat3x4 a, mat3x4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 675                                   "abs(a[2]-b[2])); return all(lessThanEqual(diff, vec4(eps))); }\n";
 676         if (cmpTypeFound[TYPE_FLOAT_MAT4X2])
 677                 stream << "bool isOk (mat4x2 a, mat4x2 b, float eps) { vec2 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 678                                   "max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec2(eps))); }\n";
 679         if (cmpTypeFound[TYPE_FLOAT_MAT4X3])
 680                 stream << "bool isOk (mat4x3 a, mat4x3 b, float eps) { vec3 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 681                                   "max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec3(eps))); }\n";
 682         if (cmpTypeFound[TYPE_FLOAT_MAT4])
 683                 stream << "bool isOk (mat4 a, mat4 b, float eps) { vec4 diff = max(max(abs(a[0]-b[0]), abs(a[1]-b[1])), "
 684                                   "max(abs(a[2]-b[2]), abs(a[3]-b[3]))); return all(lessThanEqual(diff, vec4(eps))); }\n";
 685 }
 686
 687 static void genCompareOp(ostringstream& output, const char* dstVec4Var, const ShaderCase::ValueBlock& valueBlock,
 688                                                  const char* nonFloatNamePrefix, const char* checkVarName)
 689 {
 690         bool isFirstOutput = true;
 691
 692         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 693         {
 694                 const ShaderCase::Value& val       = valueBlock.values[ndx];
 695                 const char*                              valueName = val.valueName.c_str();
 696
 697                 if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 698                 {
 699                         // Check if we're only interested in one variable (then skip if not the right one).
 700                         if (checkVarName && !deStringEqual(valueName, checkVarName))
 701                                 continue;
 702
 703                         // Prefix.
 704                         if (isFirstOutput)
 705                         {
 706                                 output << "bool RES = ";
 707                                 isFirstOutput = false;
 708                         }
 709                         else
 710                                 output << "RES = RES && ";
 711
 712                         // Generate actual comparison.
 713                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 714                                 output << "isOk(" << valueName << ", ref_" << valueName << ", 0.05);\n";
 715                         else
 716                                 output << "isOk(" << nonFloatNamePrefix << valueName << ", ref_" << valueName << ");\n";
 717                 }
 718                 // \note Uniforms are already declared in shader.
 719         }
 720
 721         if (isFirstOutput)
 722                 output << dstVec4Var << " = vec4(1.0);\n"; // \todo [petri] Should we give warning if not expect-failure case?
 723         else
 724                 output << dstVec4Var << " = vec4(RES, RES, RES, 1.0);\n";
 725 }
 726
 727 string ShaderCase::genFragmentShader(const ValueBlock& valueBlock)
 728 {
 729         ostringstream shader;
 730         const bool      usesInout                = usesShaderInoutQualifiers(m_targetVersion);
 731         const bool      customColorOut = usesInout;
 732         const char*   fragIn             = usesInout ? "in" : "varying";
 733
 734         shader << glu::getGLSLVersionDeclaration(m_targetVersion) << "\n";
 735
 736         shader << "precision mediump float;\n";
 737         shader << "precision mediump int;\n";
 738         shader << "\n";
 739
 740         if (customColorOut)
 741         {
 742                 shader << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
 743                 shader << "\n";
 744         }
 745
 746         genCompareFunctions(shader, valueBlock, true);
 747         shader << "\n";
 748
 749         // Declarations (varying, reference for each output).
 750         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 751         {
 752                 const ShaderCase::Value& val              = valueBlock.values[ndx];
 753                 DataType                                 floatType      = getDataTypeFloatScalars(val.dataType);
 754                 const char*                              floatTypeStr = getDataTypeName(floatType);
 755                 const char*                              refTypeStr   = getDataTypeName(val.dataType);
 756
 757                 if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 758                 {
 759                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 760                                 shader << fragIn << " " << floatTypeStr << " " << val.valueName << ";\n";
 761                         else
 762                                 shader << fragIn << " " << floatTypeStr << " v_" << val.valueName << ";\n";
 763
 764                         shader << "uniform " << refTypeStr << " ref_" << val.valueName << ";\n";
 765                 }
 766         }
 767
 768         shader << "\n";
 769         shader << "void main()\n";
 770         shader << "{\n";
 771
 772         shader << " ";
 773         genCompareOp(shader, customColorOut ? "dEQP_FragColor" : "gl_FragColor", valueBlock, "v_", DE_NULL);
 774
 775         shader << "}\n";
 776         return shader.str();
 777 }
 778
 779 // Specialize a shader for the vertex shader test case.
 780 string ShaderCase::specializeVertexShader(const char* src, const ValueBlock& valueBlock)
 781 {
 782         ostringstream decl;
 783         ostringstream setup;
 784         ostringstream output;
 785         const bool      usesInout = usesShaderInoutQualifiers(m_targetVersion);
 786         const char*   vtxIn             = usesInout ? "in" : "attribute";
 787         const char*   vtxOut    = usesInout ? "out" : "varying";
 788
 789         // Output (write out position).
 790         output << "gl_Position = dEQP_Position;\n";
 791
 792         // Declarations (position + attribute for each input, varying for each output).
 793         decl << vtxIn << " highp vec4 dEQP_Position;\n";
 794         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 795         {
 796                 const ShaderCase::Value& val              = valueBlock.values[ndx];
 797                 const char*                              valueName      = val.valueName.c_str();
 798                 DataType                                 floatType      = getDataTypeFloatScalars(val.dataType);
 799                 const char*                              floatTypeStr = getDataTypeName(floatType);
 800                 const char*                              refTypeStr   = getDataTypeName(val.dataType);
 801
 802                 if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 803                 {
 804                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 805                         {
 806                                 decl << vtxIn << " " << floatTypeStr << " " << valueName << ";\n";
 807                         }
 808                         else
 809                         {
 810                                 decl << vtxIn << " " << floatTypeStr << " a_" << valueName << ";\n";
 811                                 setup << refTypeStr << " " << valueName << " = " << refTypeStr << "(a_" << valueName << ");\n";
 812                         }
 813                 }
 814                 else if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 815                 {
 816                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 817                                 decl << vtxOut << " " << floatTypeStr << " " << valueName << ";\n";
 818                         else
 819                         {
 820                                 decl << vtxOut << " " << floatTypeStr << " v_" << valueName << ";\n";
 821                                 decl << refTypeStr << " " << valueName << ";\n";
 822
 823                                 output << "v_" << valueName << " = " << floatTypeStr << "(" << valueName << ");\n";
 824                         }
 825                 }
 826         }
 827
 828         // Shader specialization.
 829         map<string, string> params;
 830         params.insert(pair<string, string>("DECLARATIONS", decl.str()));
 831         params.insert(pair<string, string>("SETUP", setup.str()));
 832         params.insert(pair<string, string>("OUTPUT", output.str()));
 833         params.insert(pair<string, string>("POSITION_FRAG_COLOR", "gl_Position"));
 834
 835         StringTemplate tmpl(src);
 836         return tmpl.specialize(params);
 837 }
 838
 839 // Specialize a shader for the fragment shader test case.
 840 string ShaderCase::specializeFragmentShader(const char* src, const ValueBlock& valueBlock)
 841 {
 842         ostringstream decl;
 843         ostringstream setup;
 844         ostringstream output;
 845
 846         const bool  usesInout     = usesShaderInoutQualifiers(m_targetVersion);
 847         const bool  customColorOut = usesInout;
 848         const char* fragIn                 = usesInout ? "in" : "varying";
 849         const char* fragColor     = customColorOut ? "dEQP_FragColor" : "gl_FragColor";
 850
 851         genCompareFunctions(decl, valueBlock, false);
 852         genCompareOp(output, fragColor, valueBlock, "", DE_NULL);
 853
 854         if (customColorOut)
 855                 decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
 856
 857         for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 858         {
 859                 const ShaderCase::Value& val              = valueBlock.values[ndx];
 860                 const char*                              valueName      = val.valueName.c_str();
 861                 DataType                                 floatType      = getDataTypeFloatScalars(val.dataType);
 862                 const char*                              floatTypeStr = getDataTypeName(floatType);
 863                 const char*                              refTypeStr   = getDataTypeName(val.dataType);
 864
 865                 if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 866                 {
 867                         if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 868                                 decl << fragIn << " " << floatTypeStr << " " << valueName << ";\n";
 869                         else
 870                         {
 871                                 decl << fragIn << " " << floatTypeStr << " v_" << valueName << ";\n";
 872                                 std::string offset =
 873                                         isDataTypeIntOrIVec(val.dataType) ?
 874                                                 " * 1.0025" :
 875                                                 ""; // \todo [petri] bit of a hack to avoid errors in chop() due to varying interpolation
 876                                 setup << refTypeStr << " " << valueName << " = " << refTypeStr << "(v_" << valueName << offset
 877                                           << ");\n";
 878                         }
 879                 }
 880                 else if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 881                 {
 882                         decl << "uniform " << refTypeStr << " ref_" << valueName << ";\n";
 883                         decl << refTypeStr << " " << valueName << ";\n";
 884                 }
 885         }
 886
 887         /* \todo [2010-04-01 petri] Check all outputs. */
 888
 889         // Shader specialization.
 890         map<string, string> params;
 891         params.insert(pair<string, string>("DECLARATIONS", decl.str()));
 892         params.insert(pair<string, string>("SETUP", setup.str()));
 893         params.insert(pair<string, string>("OUTPUT", output.str()));
 894         params.insert(pair<string, string>("POSITION_FRAG_COLOR", fragColor));
 895
 896         StringTemplate tmpl(src);
 897         return tmpl.specialize(params);
 898 }
 899
 900 void ShaderCase::specializeShaders(const char* vertexSource, const char* fragmentSource, string& outVertexSource,
 901                                                                    string& outFragmentSource, const ValueBlock& valueBlock)
 902 {
 903         const bool usesInout      = usesShaderInoutQualifiers(m_targetVersion);
 904         const bool customColorOut = usesInout;
 905
 906         // Vertex shader specialization.
 907         {
 908                 ostringstream decl;
 909                 ostringstream setup;
 910                 const char*   vtxIn = usesInout ? "in" : "attribute";
 911
 912                 decl << vtxIn << " highp vec4 dEQP_Position;\n";
 913
 914                 for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 915                 {
 916                         const ShaderCase::Value& val     = valueBlock.values[ndx];
 917                         const char*                              typeStr = getDataTypeName(val.dataType);
 918
 919                         if (val.storageType == ShaderCase::Value::STORAGE_INPUT)
 920                         {
 921                                 if (getDataTypeScalarType(val.dataType) == TYPE_FLOAT)
 922                                 {
 923                                         decl << vtxIn << " " << typeStr << " " << val.valueName << ";\n";
 924                                 }
 925                                 else
 926                                 {
 927                                         DataType        floatType       = getDataTypeFloatScalars(val.dataType);
 928                                         const char* floatTypeStr = getDataTypeName(floatType);
 929
 930                                         decl << vtxIn << " " << floatTypeStr << " a_" << val.valueName << ";\n";
 931                                         setup << typeStr << " " << val.valueName << " = " << typeStr << "(a_" << val.valueName << ");\n";
 932                                 }
 933                         }
 934                         else if (val.storageType == ShaderCase::Value::STORAGE_UNIFORM && val.valueName.find('.') == string::npos)
 935                         {
 936                                 decl << "uniform " << typeStr << " " << val.valueName << ";\n";
 937                         }
 938                 }
 939
 940                 map<string, string> params;
 941                 params.insert(pair<string, string>("VERTEX_DECLARATIONS", decl.str()));
 942                 params.insert(pair<string, string>("VERTEX_SETUP", setup.str()));
 943                 params.insert(pair<string, string>("VERTEX_OUTPUT", string("gl_Position = dEQP_Position;\n")));
 944                 StringTemplate tmpl(vertexSource);
 945                 outVertexSource = tmpl.specialize(params);
 946         }
 947
 948         // Fragment shader specialization.
 949         {
 950                 ostringstream decl;
 951                 ostringstream output;
 952                 const char*   fragColor = customColorOut ? "dEQP_FragColor" : "gl_FragColor";
 953
 954                 genCompareFunctions(decl, valueBlock, false);
 955                 genCompareOp(output, fragColor, valueBlock, "", DE_NULL);
 956
 957                 if (customColorOut)
 958                         decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
 959
 960                 for (int ndx = 0; ndx < (int)valueBlock.values.size(); ndx++)
 961                 {
 962                         const ShaderCase::Value& val            = valueBlock.values[ndx];
 963                         const char*                              valueName  = val.valueName.c_str();
 964                         const char*                              refTypeStr = getDataTypeName(val.dataType);
 965
 966                         if (val.storageType == ShaderCase::Value::STORAGE_OUTPUT)
 967                         {
 968                                 decl << "uniform " << refTypeStr << " ref_" << valueName << ";\n";
 969                                 decl << refTypeStr << " " << valueName << ";\n";
 970                         }
 971                         else if (val.storageType == ShaderCase::Value::STORAGE_UNIFORM && val.valueName.find('.') == string::npos)
 972                         {
 973                                 decl << "uniform " << refTypeStr << " " << valueName << ";\n";
 974                         }
 975                 }
 976
 977                 map<string, string> params;
 978                 params.insert(pair<string, string>("FRAGMENT_DECLARATIONS", decl.str()));
 979                 params.insert(pair<string, string>("FRAGMENT_OUTPUT", output.str()));
 980                 params.insert(pair<string, string>("FRAG_COLOR", fragColor));
 981                 StringTemplate tmpl(fragmentSource);
 982                 outFragmentSource = tmpl.specialize(params);
 983         }
 984 }
 985
 986 void ShaderCase::dumpValues(const ValueBlock& valueBlock, int arrayNdx)
 987 {
 988         vector<vector<float> > attribValues;
 989
 990         int numValues = (int)valueBlock.values.size();
 991         for (int valNdx = 0; valNdx < numValues; valNdx++)
 992         {
 993                 const ShaderCase::Value& val            = valueBlock.values[valNdx];
 994                 const char*                              valueName  = val.valueName.c_str();
 995                 DataType                                 dataType   = val.dataType;
 996                 int                                              scalarSize = getDataTypeScalarSize(val.dataType);
 997                 ostringstream                    result;
 998
 999                 result << "    ";
1000                 if (val.storageType == Value::STORAGE_INPUT)
1001                         result << "input ";
1002                 else if (val.storageType == Value::STORAGE_UNIFORM)
1003                         result << "uniform ";
1004                 else if (val.storageType == Value::STORAGE_OUTPUT)
1005                         result << "expected ";
1006
1007                 result << getDataTypeName(dataType) << " " << valueName << ":";
1008
1009                 if (isDataTypeScalar(dataType))
1010                         result << " ";
1011                 if (isDataTypeVector(dataType))
1012                         result << " [ ";
1013                 else if (isDataTypeMatrix(dataType))
1014                         result << "\n";
1015
1016                 if (isDataTypeScalarOrVector(dataType))
1017                 {
1018                         for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++)
1019                         {
1020                                 int                                       elemNdx = (val.arrayLength == 1) ? 0 : arrayNdx;
1021                                 const Value::Element& e           = val.elements[elemNdx * scalarSize + scalarNdx];
1022                                 result << ((scalarNdx != 0) ? ", " : "");
1023
1024                                 if (isDataTypeFloatOrVec(dataType))
1025                                         result << e.float32;
1026                                 else if (isDataTypeIntOrIVec(dataType))
1027                                         result << e.int32;
1028                                 else if (isDataTypeBoolOrBVec(dataType))
1029                                         result << (e.bool32 ? "true" : "false");
1030                         }
1031                 }
1032                 else if (isDataTypeMatrix(dataType))
1033                 {
1034                         int numRows = getDataTypeMatrixNumRows(dataType);
1035                         int numCols = getDataTypeMatrixNumColumns(dataType);
1036                         for (int rowNdx = 0; rowNdx < numRows; rowNdx++)
1037                         {
1038                                 result << "       [ ";
1039                                 for (int colNdx = 0; colNdx < numCols; colNdx++)
1040                                 {
1041                                         int   elemNdx = (val.arrayLength == 1) ? 0 : arrayNdx;
1042                                         float v           = val.elements[elemNdx * scalarSize + rowNdx * numCols + colNdx].float32;
1043                                         result << ((colNdx == 0) ? "" : ", ") << v;
1044                                 }
1045                                 result << " ]\n";
1046                         }
1047                 }
1048
1049                 if (isDataTypeScalar(dataType))
1050                         result << "\n";
1051                 else if (isDataTypeVector(dataType))
1052                         result << " ]\n";
1053
1054                 m_testCtx.getLog() << TestLog::Message << result.str() << TestLog::EndMessage;
1055         }
1056 }
1057
1058 } // sl
1059 } // deqp