modules/gles3/functional/es3fShaderIndexingTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader indexing (arrays, vector, matrices) tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fShaderIndexingTests.hpp"
  25 #include "glsShaderRenderCase.hpp"
  26 #include "gluShaderUtil.hpp"
  27 #include "tcuStringTemplate.hpp"
  28
  29 #include "deInt32.h"
  30 #include "deMemory.h"
  31
  32 #include <map>
  33
  34 #include "glwEnums.hpp"
  35 #include "glwFunctions.hpp"
  36
  37 using namespace std;
  38 using namespace tcu;
  39 using namespace glu;
  40 using namespace deqp::gls;
  41
  42 namespace deqp
  43 {
  44 namespace gles3
  45 {
  46 namespace Functional
  47 {
  48
  49 enum IndexAccessType
  50 {
  51         INDEXACCESS_STATIC = 0,
  52         INDEXACCESS_DYNAMIC,
  53         INDEXACCESS_STATIC_LOOP,
  54         INDEXACCESS_DYNAMIC_LOOP,
  55
  56         INDEXACCESS_LAST
  57 };
  58
  59 static const char* getIndexAccessTypeName (IndexAccessType accessType)
  60 {
  61         static const char* s_names[INDEXACCESS_LAST] =
  62         {
  63                 "static",
  64                 "dynamic",
  65                 "static_loop",
  66                 "dynamic_loop"
  67         };
  68
  69         DE_ASSERT(deInBounds32((int)accessType, 0, INDEXACCESS_LAST));
  70         return s_names[(int)accessType];
  71 }
  72
  73 enum VectorAccessType
  74 {
  75         DIRECT = 0,
  76         COMPONENT,
  77         SUBSCRIPT_STATIC,
  78         SUBSCRIPT_DYNAMIC,
  79         SUBSCRIPT_STATIC_LOOP,
  80         SUBSCRIPT_DYNAMIC_LOOP,
  81
  82         VECTORACCESS_LAST
  83 };
  84
  85 static const char* getVectorAccessTypeName (VectorAccessType accessType)
  86 {
  87         static const char* s_names[VECTORACCESS_LAST] =
  88         {
  89                 "direct",
  90                 "component",
  91                 "static_subscript",
  92                 "dynamic_subscript",
  93                 "static_loop_subscript",
  94                 "dynamic_loop_subscript"
  95         };
  96
  97         DE_ASSERT(deInBounds32((int)accessType, 0, VECTORACCESS_LAST));
  98         return s_names[(int)accessType];
  99 }
 100
 101 void evalArrayCoordsFloat               (ShaderEvalContext& c) { c.color.x()    = 1.875f * c.coords.x(); }
 102 void evalArrayCoordsVec2                (ShaderEvalContext& c) { c.color.xy()   = 1.875f * c.coords.swizzle(0,1); }
 103 void evalArrayCoordsVec3                (ShaderEvalContext& c) { c.color.xyz()  = 1.875f * c.coords.swizzle(0,1,2); }
 104 void evalArrayCoordsVec4                (ShaderEvalContext& c) { c.color                = 1.875f * c.coords; }
 105
 106 static ShaderEvalFunc getArrayCoordsEvalFunc (DataType dataType)
 107 {
 108         if (dataType == TYPE_FLOAT)                             return evalArrayCoordsFloat;
 109         else if (dataType == TYPE_FLOAT_VEC2)   return evalArrayCoordsVec2;
 110         else if (dataType == TYPE_FLOAT_VEC3)   return evalArrayCoordsVec3;
 111         else if (dataType == TYPE_FLOAT_VEC4)   return evalArrayCoordsVec4;
 112
 113         DE_FATAL("Invalid data type.");
 114         return NULL;
 115 }
 116
 117 void evalArrayUniformFloat              (ShaderEvalContext& c) { c.color.x()    = 1.875f * c.constCoords.x(); }
 118 void evalArrayUniformVec2               (ShaderEvalContext& c) { c.color.xy()   = 1.875f * c.constCoords.swizzle(0,1); }
 119 void evalArrayUniformVec3               (ShaderEvalContext& c) { c.color.xyz()  = 1.875f * c.constCoords.swizzle(0,1,2); }
 120 void evalArrayUniformVec4               (ShaderEvalContext& c) { c.color                = 1.875f * c.constCoords; }
 121
 122 static ShaderEvalFunc getArrayUniformEvalFunc (DataType dataType)
 123 {
 124         if (dataType == TYPE_FLOAT)                             return evalArrayUniformFloat;
 125         else if (dataType == TYPE_FLOAT_VEC2)   return evalArrayUniformVec2;
 126         else if (dataType == TYPE_FLOAT_VEC3)   return evalArrayUniformVec3;
 127         else if (dataType == TYPE_FLOAT_VEC4)   return evalArrayUniformVec4;
 128
 129         DE_FATAL("Invalid data type.");
 130         return NULL;
 131 }
 132
 133 // ShaderIndexingCase
 134
 135 class ShaderIndexingCase : public ShaderRenderCase
 136 {
 137 public:
 138                                                                 ShaderIndexingCase              (Context& context, const char* name, const char* description, bool isVertexCase, DataType varType, ShaderEvalFunc evalFunc, const char* vertShaderSource, const char* fragShaderSource);
 139         virtual                                         ~ShaderIndexingCase             (void);
 140
 141 private:
 142                                                                 ShaderIndexingCase              (const ShaderIndexingCase&);    // not allowed!
 143         ShaderIndexingCase&                     operator=                               (const ShaderIndexingCase&);    // not allowed!
 144
 145         virtual void                            setup                                   (int programID);
 146         virtual void                            setupUniforms                   (int programID, const Vec4& constCoords);
 147
 148         DataType                                        m_varType;
 149 };
 150
 151 ShaderIndexingCase::ShaderIndexingCase (Context& context, const char* name, const char* description, bool isVertexCase, DataType varType, ShaderEvalFunc evalFunc, const char* vertShaderSource, const char* fragShaderSource)
 152         : ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, description, isVertexCase, evalFunc)
 153 {
 154         m_varType                       = varType;
 155         m_vertShaderSource      = vertShaderSource;
 156         m_fragShaderSource      = fragShaderSource;
 157 }
 158
 159 ShaderIndexingCase::~ShaderIndexingCase (void)
 160 {
 161 }
 162
 163 void ShaderIndexingCase::setup (int programID)
 164 {
 165         DE_UNREF(programID);
 166 }
 167
 168 void ShaderIndexingCase::setupUniforms (int programID, const Vec4& constCoords)
 169 {
 170         const glw::Functions& gl = m_renderCtx.getFunctions();
 171
 172         DE_UNREF(constCoords);
 173
 174         int arrLoc = gl.getUniformLocation(programID, "u_arr");
 175         if (arrLoc != -1)
 176         {
 177                 //int scalarSize = getDataTypeScalarSize(m_varType);
 178                 if (m_varType == TYPE_FLOAT)
 179                 {
 180                         float arr[4];
 181                         arr[0] = constCoords.x();
 182                         arr[1] = constCoords.x() * 0.5f;
 183                         arr[2] = constCoords.x() * 0.25f;
 184                         arr[3] = constCoords.x() * 0.125f;
 185                         gl.uniform1fv(arrLoc, 4, &arr[0]);
 186                 }
 187                 else if (m_varType == TYPE_FLOAT_VEC2)
 188                 {
 189                         Vec2 arr[4];
 190                         arr[0] = constCoords.swizzle(0,1);
 191                         arr[1] = constCoords.swizzle(0,1) * 0.5f;
 192                         arr[2] = constCoords.swizzle(0,1) * 0.25f;
 193                         arr[3] = constCoords.swizzle(0,1) * 0.125f;
 194                         gl.uniform2fv(arrLoc, 4, arr[0].getPtr());
 195                 }
 196                 else if (m_varType == TYPE_FLOAT_VEC3)
 197                 {
 198                         Vec3 arr[4];
 199                         arr[0] = constCoords.swizzle(0,1,2);
 200                         arr[1] = constCoords.swizzle(0,1,2) * 0.5f;
 201                         arr[2] = constCoords.swizzle(0,1,2) * 0.25f;
 202                         arr[3] = constCoords.swizzle(0,1,2) * 0.125f;
 203                         gl.uniform3fv(arrLoc, 4, arr[0].getPtr());
 204                 }
 205                 else if (m_varType == TYPE_FLOAT_VEC4)
 206                 {
 207                         Vec4 arr[4];
 208                         arr[0] = constCoords.swizzle(0,1,2,3);
 209                         arr[1] = constCoords.swizzle(0,1,2,3) * 0.5f;
 210                         arr[2] = constCoords.swizzle(0,1,2,3) * 0.25f;
 211                         arr[3] = constCoords.swizzle(0,1,2,3) * 0.125f;
 212                         gl.uniform4fv(arrLoc, 4, arr[0].getPtr());
 213                 }
 214                 else
 215                         throw tcu::TestError("u_arr should not have location assigned in this test case");
 216         }
 217 }
 218
 219 // Helpers.
 220
 221 static ShaderIndexingCase* createVaryingArrayCase (Context& context, const char* caseName, const char* description, DataType varType, IndexAccessType vertAccess, IndexAccessType fragAccess)
 222 {
 223         std::ostringstream vtx;
 224         vtx << "#version 300 es\n";
 225         vtx << "in highp vec4 a_position;\n";
 226         vtx << "in highp vec4 a_coords;\n";
 227         if (vertAccess == INDEXACCESS_DYNAMIC)
 228                 vtx << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n";
 229         else if (vertAccess == INDEXACCESS_DYNAMIC_LOOP)
 230                 vtx << "uniform mediump int ui_four;\n";
 231         vtx << "out ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n";
 232         vtx << "\n";
 233         vtx << "void main()\n";
 234         vtx << "{\n";
 235         vtx << "        gl_Position = a_position;\n";
 236         if (vertAccess == INDEXACCESS_STATIC)
 237         {
 238                 vtx << "        var[0] = ${VAR_TYPE}(a_coords);\n";
 239                 vtx << "        var[1] = ${VAR_TYPE}(a_coords) * 0.5;\n";
 240                 vtx << "        var[2] = ${VAR_TYPE}(a_coords) * 0.25;\n";
 241                 vtx << "        var[3] = ${VAR_TYPE}(a_coords) * 0.125;\n";
 242         }
 243         else if (vertAccess == INDEXACCESS_DYNAMIC)
 244         {
 245                 vtx << "        var[ui_zero]  = ${VAR_TYPE}(a_coords);\n";
 246                 vtx << "        var[ui_one]   = ${VAR_TYPE}(a_coords) * 0.5;\n";
 247                 vtx << "        var[ui_two]   = ${VAR_TYPE}(a_coords) * 0.25;\n";
 248                 vtx << "        var[ui_three] = ${VAR_TYPE}(a_coords) * 0.125;\n";
 249         }
 250         else if (vertAccess == INDEXACCESS_STATIC_LOOP)
 251         {
 252                 vtx << "        ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n";
 253                 vtx << "        for (int i = 0; i < 4; i++)\n";
 254                 vtx << "        {\n";
 255                 vtx << "                var[i] = ${VAR_TYPE}(coords);\n";
 256                 vtx << "                coords = coords * 0.5;\n";
 257                 vtx << "        }\n";
 258         }
 259         else
 260         {
 261                 DE_ASSERT(vertAccess == INDEXACCESS_DYNAMIC_LOOP);
 262                 vtx << "        ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n";
 263                 vtx << "        for (int i = 0; i < ui_four; i++)\n";
 264                 vtx << "        {\n";
 265                 vtx << "                var[i] = ${VAR_TYPE}(coords);\n";
 266                 vtx << "                coords = coords * 0.5;\n";
 267                 vtx << "        }\n";
 268         }
 269         vtx << "}\n";
 270
 271         std::ostringstream frag;
 272         frag << "#version 300 es\n";
 273         frag << "precision mediump int;\n";
 274         frag << "layout(location = 0) out mediump vec4 o_color;\n";
 275         if (fragAccess == INDEXACCESS_DYNAMIC)
 276                 frag << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n";
 277         else if (fragAccess == INDEXACCESS_DYNAMIC_LOOP)
 278                 frag << "uniform int ui_four;\n";
 279         frag << "in ${PRECISION} ${VAR_TYPE} var[${ARRAY_LEN}];\n";
 280         frag << "\n";
 281         frag << "void main()\n";
 282         frag << "{\n";
 283         frag << "       ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n";
 284         if (fragAccess == INDEXACCESS_STATIC)
 285         {
 286                 frag << "       res += var[0];\n";
 287                 frag << "       res += var[1];\n";
 288                 frag << "       res += var[2];\n";
 289                 frag << "       res += var[3];\n";
 290         }
 291         else if (fragAccess == INDEXACCESS_DYNAMIC)
 292         {
 293                 frag << "       res += var[ui_zero];\n";
 294                 frag << "       res += var[ui_one];\n";
 295                 frag << "       res += var[ui_two];\n";
 296                 frag << "       res += var[ui_three];\n";
 297         }
 298         else if (fragAccess == INDEXACCESS_STATIC_LOOP)
 299         {
 300                 frag << "       for (int i = 0; i < 4; i++)\n";
 301                 frag << "               res += var[i];\n";
 302         }
 303         else
 304         {
 305                 DE_ASSERT(fragAccess == INDEXACCESS_DYNAMIC_LOOP);
 306                 frag << "       for (int i = 0; i < ui_four; i++)\n";
 307                 frag << "               res += var[i];\n";
 308         }
 309         frag << "       o_color = vec4(res${PADDING});\n";
 310         frag << "}\n";
 311
 312         // Fill in shader templates.
 313         map<string, string> params;
 314         params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType)));
 315         params.insert(pair<string, string>("ARRAY_LEN", "4"));
 316         params.insert(pair<string, string>("PRECISION", "mediump"));
 317
 318         if (varType == TYPE_FLOAT)
 319                 params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0"));
 320         else if (varType == TYPE_FLOAT_VEC2)
 321                 params.insert(pair<string, string>("PADDING", ", 0.0, 1.0"));
 322         else if (varType == TYPE_FLOAT_VEC3)
 323                 params.insert(pair<string, string>("PADDING", ", 1.0"));
 324         else
 325                 params.insert(pair<string, string>("PADDING", ""));
 326
 327         StringTemplate vertTemplate(vtx.str().c_str());
 328         StringTemplate fragTemplate(frag.str().c_str());
 329         string vertexShaderSource = vertTemplate.specialize(params);
 330         string fragmentShaderSource = fragTemplate.specialize(params);
 331
 332         ShaderEvalFunc evalFunc = getArrayCoordsEvalFunc(varType);
 333         return new ShaderIndexingCase(context, caseName, description, true, varType, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
 334 }
 335
 336 static ShaderIndexingCase* createUniformArrayCase (Context& context, const char* caseName, const char* description, bool isVertexCase, DataType varType, IndexAccessType readAccess)
 337 {
 338         std::ostringstream vtx;
 339         std::ostringstream frag;
 340         std::ostringstream& op = isVertexCase ? vtx : frag;
 341
 342         vtx << "#version 300 es\n";
 343         frag << "#version 300 es\n";
 344
 345         vtx << "in highp vec4 a_position;\n";
 346         vtx << "in highp vec4 a_coords;\n";
 347         frag << "layout(location = 0) out mediump vec4 o_color;\n";
 348
 349         if (isVertexCase)
 350         {
 351                 vtx << "out mediump vec4 v_color;\n";
 352                 frag << "in mediump vec4 v_color;\n";
 353         }
 354         else
 355         {
 356                 vtx << "out mediump vec4 v_coords;\n";
 357                 frag << "in mediump vec4 v_coords;\n";
 358         }
 359
 360         if (readAccess == INDEXACCESS_DYNAMIC)
 361                 op << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n";
 362         else if (readAccess == INDEXACCESS_DYNAMIC_LOOP)
 363                 op << "uniform mediump int ui_four;\n";
 364
 365         op << "uniform ${PRECISION} ${VAR_TYPE} u_arr[${ARRAY_LEN}];\n";
 366
 367         vtx << "\n";
 368         vtx << "void main()\n";
 369         vtx << "{\n";
 370         vtx << "        gl_Position = a_position;\n";
 371
 372         frag << "\n";
 373         frag << "void main()\n";
 374         frag << "{\n";
 375
 376         // Read array.
 377         op << " ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n";
 378         if (readAccess == INDEXACCESS_STATIC)
 379         {
 380                 op << " res += u_arr[0];\n";
 381                 op << " res += u_arr[1];\n";
 382                 op << " res += u_arr[2];\n";
 383                 op << " res += u_arr[3];\n";
 384         }
 385         else if (readAccess == INDEXACCESS_DYNAMIC)
 386         {
 387                 op << " res += u_arr[ui_zero];\n";
 388                 op << " res += u_arr[ui_one];\n";
 389                 op << " res += u_arr[ui_two];\n";
 390                 op << " res += u_arr[ui_three];\n";
 391         }
 392         else if (readAccess == INDEXACCESS_STATIC_LOOP)
 393         {
 394                 op << " for (int i = 0; i < 4; i++)\n";
 395                 op << "         res += u_arr[i];\n";
 396         }
 397         else
 398         {
 399                 DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP);
 400                 op << " for (int i = 0; i < ui_four; i++)\n";
 401                 op << "         res += u_arr[i];\n";
 402         }
 403
 404         if (isVertexCase)
 405         {
 406                 vtx << "        v_color = vec4(res${PADDING});\n";
 407                 frag << "       o_color = v_color;\n";
 408         }
 409         else
 410         {
 411                 vtx << "        v_coords = a_coords;\n";
 412                 frag << "       o_color = vec4(res${PADDING});\n";
 413         }
 414
 415         vtx << "}\n";
 416         frag << "}\n";
 417
 418         // Fill in shader templates.
 419         map<string, string> params;
 420         params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType)));
 421         params.insert(pair<string, string>("ARRAY_LEN", "4"));
 422         params.insert(pair<string, string>("PRECISION", "mediump"));
 423
 424         if (varType == TYPE_FLOAT)
 425                 params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0"));
 426         else if (varType == TYPE_FLOAT_VEC2)
 427                 params.insert(pair<string, string>("PADDING", ", 0.0, 1.0"));
 428         else if (varType == TYPE_FLOAT_VEC3)
 429                 params.insert(pair<string, string>("PADDING", ", 1.0"));
 430         else
 431                 params.insert(pair<string, string>("PADDING", ""));
 432
 433         StringTemplate vertTemplate(vtx.str().c_str());
 434         StringTemplate fragTemplate(frag.str().c_str());
 435         string vertexShaderSource = vertTemplate.specialize(params);
 436         string fragmentShaderSource = fragTemplate.specialize(params);
 437
 438         ShaderEvalFunc evalFunc = getArrayUniformEvalFunc(varType);
 439         return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
 440 }
 441
 442 static ShaderIndexingCase* createTmpArrayCase (Context& context, const char* caseName, const char* description, bool isVertexCase, DataType varType, IndexAccessType writeAccess, IndexAccessType readAccess)
 443 {
 444         std::ostringstream vtx;
 445         std::ostringstream frag;
 446         std::ostringstream& op = isVertexCase ? vtx : frag;
 447
 448         vtx << "#version 300 es\n";
 449         frag << "#version 300 es\n";
 450
 451         vtx << "in highp vec4 a_position;\n";
 452         vtx << "in highp vec4 a_coords;\n";
 453         frag << "layout(location = 0) out mediump vec4 o_color;\n";
 454
 455         if (isVertexCase)
 456         {
 457                 vtx << "out mediump vec4 v_color;\n";
 458                 frag << "in mediump vec4 v_color;\n";
 459         }
 460         else
 461         {
 462                 vtx << "out mediump vec4 v_coords;\n";
 463                 frag << "in mediump vec4 v_coords;\n";
 464         }
 465
 466         if (writeAccess == INDEXACCESS_DYNAMIC || readAccess == INDEXACCESS_DYNAMIC)
 467                 op << "uniform mediump int ui_zero, ui_one, ui_two, ui_three;\n";
 468
 469         if (writeAccess == INDEXACCESS_DYNAMIC_LOOP || readAccess == INDEXACCESS_DYNAMIC_LOOP)
 470                 op << "uniform mediump int ui_four;\n";
 471
 472         vtx << "\n";
 473         vtx << "void main()\n";
 474         vtx << "{\n";
 475         vtx << "        gl_Position = a_position;\n";
 476
 477         frag << "\n";
 478         frag << "void main()\n";
 479         frag << "{\n";
 480
 481         // Write array.
 482         if (isVertexCase)
 483                 op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n";
 484         else
 485                 op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n";
 486
 487         op << " ${PRECISION} ${VAR_TYPE} arr[${ARRAY_LEN}];\n";
 488         if (writeAccess == INDEXACCESS_STATIC)
 489         {
 490                 op << " arr[0] = ${VAR_TYPE}(coords);\n";
 491                 op << " arr[1] = ${VAR_TYPE}(coords) * 0.5;\n";
 492                 op << " arr[2] = ${VAR_TYPE}(coords) * 0.25;\n";
 493                 op << " arr[3] = ${VAR_TYPE}(coords) * 0.125;\n";
 494         }
 495         else if (writeAccess == INDEXACCESS_DYNAMIC)
 496         {
 497                 op << " arr[ui_zero]  = ${VAR_TYPE}(coords);\n";
 498                 op << " arr[ui_one]   = ${VAR_TYPE}(coords) * 0.5;\n";
 499                 op << " arr[ui_two]   = ${VAR_TYPE}(coords) * 0.25;\n";
 500                 op << " arr[ui_three] = ${VAR_TYPE}(coords) * 0.125;\n";
 501         }
 502         else if (writeAccess == INDEXACCESS_STATIC_LOOP)
 503         {
 504                 op << " for (int i = 0; i < 4; i++)\n";
 505                 op << " {\n";
 506                 op << "         arr[i] = ${VAR_TYPE}(coords);\n";
 507                 op << "         coords = coords * 0.5;\n";
 508                 op << " }\n";
 509         }
 510         else
 511         {
 512                 DE_ASSERT(writeAccess == INDEXACCESS_DYNAMIC_LOOP);
 513                 op << " for (int i = 0; i < ui_four; i++)\n";
 514                 op << " {\n";
 515                 op << "         arr[i] = ${VAR_TYPE}(coords);\n";
 516                 op << "         coords = coords * 0.5;\n";
 517                 op << " }\n";
 518         }
 519
 520         // Read array.
 521         op << " ${PRECISION} ${VAR_TYPE} res = ${VAR_TYPE}(0.0);\n";
 522         if (readAccess == INDEXACCESS_STATIC)
 523         {
 524                 op << " res += arr[0];\n";
 525                 op << " res += arr[1];\n";
 526                 op << " res += arr[2];\n";
 527                 op << " res += arr[3];\n";
 528         }
 529         else if (readAccess == INDEXACCESS_DYNAMIC)
 530         {
 531                 op << " res += arr[ui_zero];\n";
 532                 op << " res += arr[ui_one];\n";
 533                 op << " res += arr[ui_two];\n";
 534                 op << " res += arr[ui_three];\n";
 535         }
 536         else if (readAccess == INDEXACCESS_STATIC_LOOP)
 537         {
 538                 op << " for (int i = 0; i < 4; i++)\n";
 539                 op << "         res += arr[i];\n";
 540         }
 541         else
 542         {
 543                 DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP);
 544                 op << " for (int i = 0; i < ui_four; i++)\n";
 545                 op << "         res += arr[i];\n";
 546         }
 547
 548         if (isVertexCase)
 549         {
 550                 vtx << "        v_color = vec4(res${PADDING});\n";
 551                 frag << "       o_color = v_color;\n";
 552         }
 553         else
 554         {
 555                 vtx << "        v_coords = a_coords;\n";
 556                 frag << "       o_color = vec4(res${PADDING});\n";
 557         }
 558
 559         vtx << "}\n";
 560         frag << "}\n";
 561
 562         // Fill in shader templates.
 563         map<string, string> params;
 564         params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType)));
 565         params.insert(pair<string, string>("ARRAY_LEN", "4"));
 566         params.insert(pair<string, string>("PRECISION", "mediump"));
 567
 568         if (varType == TYPE_FLOAT)
 569                 params.insert(pair<string, string>("PADDING", ", 0.0, 0.0, 1.0"));
 570         else if (varType == TYPE_FLOAT_VEC2)
 571                 params.insert(pair<string, string>("PADDING", ", 0.0, 1.0"));
 572         else if (varType == TYPE_FLOAT_VEC3)
 573                 params.insert(pair<string, string>("PADDING", ", 1.0"));
 574         else
 575                 params.insert(pair<string, string>("PADDING", ""));
 576
 577         StringTemplate vertTemplate(vtx.str().c_str());
 578         StringTemplate fragTemplate(frag.str().c_str());
 579         string vertexShaderSource = vertTemplate.specialize(params);
 580         string fragmentShaderSource = fragTemplate.specialize(params);
 581
 582         ShaderEvalFunc evalFunc = getArrayCoordsEvalFunc(varType);
 583         return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
 584 }
 585
 586 // VECTOR SUBSCRIPT.
 587
 588 void evalSubscriptVec2 (ShaderEvalContext& c) { c.color.xyz() = Vec3(c.coords.x() + 0.5f*c.coords.y()); }
 589 void evalSubscriptVec3 (ShaderEvalContext& c) { c.color.xyz() = Vec3(c.coords.x() + 0.5f*c.coords.y() + 0.25f*c.coords.z()); }
 590 void evalSubscriptVec4 (ShaderEvalContext& c) { c.color.xyz() = Vec3(c.coords.x() + 0.5f*c.coords.y() + 0.25f*c.coords.z() + 0.125f*c.coords.w()); }
 591
 592 static ShaderEvalFunc getVectorSubscriptEvalFunc (DataType dataType)
 593 {
 594         if (dataType == TYPE_FLOAT_VEC2)                return evalSubscriptVec2;
 595         else if (dataType == TYPE_FLOAT_VEC3)   return evalSubscriptVec3;
 596         else if (dataType == TYPE_FLOAT_VEC4)   return evalSubscriptVec4;
 597
 598         DE_FATAL("Invalid data type.");
 599         return NULL;
 600 }
 601
 602 static ShaderIndexingCase* createVectorSubscriptCase (Context& context, const char* caseName, const char* description, bool isVertexCase, DataType varType, VectorAccessType writeAccess, VectorAccessType readAccess)
 603 {
 604         std::ostringstream vtx;
 605         std::ostringstream frag;
 606         std::ostringstream& op = isVertexCase ? vtx : frag;
 607
 608         int                     vecLen          = getDataTypeScalarSize(varType);
 609         const char*     vecLenName      = getIntUniformName(vecLen);
 610
 611         vtx << "#version 300 es\n";
 612         frag << "#version 300 es\n";
 613
 614         vtx << "in highp vec4 a_position;\n";
 615         vtx << "in highp vec4 a_coords;\n";
 616         frag << "layout(location = 0) out mediump vec4 o_color;\n";
 617
 618         if (isVertexCase)
 619         {
 620                 vtx << "out mediump vec3 v_color;\n";
 621                 frag << "in mediump vec3 v_color;\n";
 622         }
 623         else
 624         {
 625                 vtx << "out mediump vec4 v_coords;\n";
 626                 frag << "in mediump vec4 v_coords;\n";
 627         }
 628
 629         if (writeAccess == SUBSCRIPT_DYNAMIC || readAccess == SUBSCRIPT_DYNAMIC)
 630         {
 631                 op << "uniform mediump int ui_zero";
 632                 if (vecLen >= 2) op << ", ui_one";
 633                 if (vecLen >= 3) op << ", ui_two";
 634                 if (vecLen >= 4) op << ", ui_three";
 635                 op << ";\n";
 636         }
 637
 638         if (writeAccess == SUBSCRIPT_DYNAMIC_LOOP || readAccess == SUBSCRIPT_DYNAMIC_LOOP)
 639                 op << "uniform mediump int " << vecLenName << ";\n";
 640
 641         vtx << "\n";
 642         vtx << "void main()\n";
 643         vtx << "{\n";
 644         vtx << "        gl_Position = a_position;\n";
 645
 646         frag << "\n";
 647         frag << "void main()\n";
 648         frag << "{\n";
 649
 650         // Write vector.
 651         if (isVertexCase)
 652                 op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(a_coords);\n";
 653         else
 654                 op << " ${PRECISION} ${VAR_TYPE} coords = ${VAR_TYPE}(v_coords);\n";
 655
 656         op << " ${PRECISION} ${VAR_TYPE} tmp;\n";
 657         if (writeAccess == DIRECT)
 658                 op << " tmp = coords.${SWIZZLE} * vec4(1.0, 0.5, 0.25, 0.125).${SWIZZLE};\n";
 659         else if (writeAccess == COMPONENT)
 660         {
 661                 op << " tmp.x = coords.x;\n";
 662                 if (vecLen >= 2) op << "        tmp.y = coords.y * 0.5;\n";
 663                 if (vecLen >= 3) op << "        tmp.z = coords.z * 0.25;\n";
 664                 if (vecLen >= 4) op << "        tmp.w = coords.w * 0.125;\n";
 665         }
 666         else if (writeAccess == SUBSCRIPT_STATIC)
 667         {
 668                 op << " tmp[0] = coords.x;\n";
 669                 if (vecLen >= 2) op << "        tmp[1] = coords.y * 0.5;\n";
 670                 if (vecLen >= 3) op << "        tmp[2] = coords.z * 0.25;\n";
 671                 if (vecLen >= 4) op << "        tmp[3] = coords.w * 0.125;\n";
 672         }
 673         else if (writeAccess == SUBSCRIPT_DYNAMIC)
 674         {
 675                 op << " tmp[ui_zero]  = coords.x;\n";
 676                 if (vecLen >= 2) op << "        tmp[ui_one]   = coords.y * 0.5;\n";
 677                 if (vecLen >= 3) op << "        tmp[ui_two]   = coords.z * 0.25;\n";
 678                 if (vecLen >= 4) op << "        tmp[ui_three] = coords.w * 0.125;\n";
 679         }
 680         else if (writeAccess == SUBSCRIPT_STATIC_LOOP)
 681         {
 682                 op << " for (int i = 0; i < " << vecLen << "; i++)\n";
 683                 op << " {\n";
 684                 op << "         tmp[i] = coords.x;\n";
 685                 op << "         coords = coords.${ROT_SWIZZLE} * 0.5;\n";
 686                 op << " }\n";
 687         }
 688         else
 689         {
 690                 DE_ASSERT(writeAccess == SUBSCRIPT_DYNAMIC_LOOP);
 691                 op << " for (int i = 0; i < " << vecLenName << "; i++)\n";
 692                 op << " {\n";
 693                 op << "         tmp[i] = coords.x;\n";
 694                 op << "         coords = coords.${ROT_SWIZZLE} * 0.5;\n";
 695                 op << " }\n";
 696         }
 697
 698         // Read vector.
 699         op << " ${PRECISION} float res = 0.0;\n";
 700         if (readAccess == DIRECT)
 701                 op << " res = dot(tmp, ${VAR_TYPE}(1.0));\n";
 702         else if (readAccess == COMPONENT)
 703         {
 704                 op << " res += tmp.x;\n";
 705                 if (vecLen >= 2) op << "        res += tmp.y;\n";
 706                 if (vecLen >= 3) op << "        res += tmp.z;\n";
 707                 if (vecLen >= 4) op << "        res += tmp.w;\n";
 708         }
 709         else if (readAccess == SUBSCRIPT_STATIC)
 710         {
 711                 op << " res += tmp[0];\n";
 712                 if (vecLen >= 2) op << "        res += tmp[1];\n";
 713                 if (vecLen >= 3) op << "        res += tmp[2];\n";
 714                 if (vecLen >= 4) op << "        res += tmp[3];\n";
 715         }
 716         else if (readAccess == SUBSCRIPT_DYNAMIC)
 717         {
 718                 op << " res += tmp[ui_zero];\n";
 719                 if (vecLen >= 2) op << "        res += tmp[ui_one];\n";
 720                 if (vecLen >= 3) op << "        res += tmp[ui_two];\n";
 721                 if (vecLen >= 4) op << "        res += tmp[ui_three];\n";
 722         }
 723         else if (readAccess == SUBSCRIPT_STATIC_LOOP)
 724         {
 725                 op << " for (int i = 0; i < " << vecLen << "; i++)\n";
 726                 op << "         res += tmp[i];\n";
 727         }
 728         else
 729         {
 730                 DE_ASSERT(readAccess == SUBSCRIPT_DYNAMIC_LOOP);
 731                 op << " for (int i = 0; i < " << vecLenName << "; i++)\n";
 732                 op << "         res += tmp[i];\n";
 733         }
 734
 735         if (isVertexCase)
 736         {
 737                 vtx << "        v_color = vec3(res);\n";
 738                 frag << "       o_color = vec4(v_color.rgb, 1.0);\n";
 739         }
 740         else
 741         {
 742                 vtx << "        v_coords = a_coords;\n";
 743                 frag << "       o_color = vec4(vec3(res), 1.0);\n";
 744         }
 745
 746         vtx << "}\n";
 747         frag << "}\n";
 748
 749         // Fill in shader templates.
 750         static const char* s_swizzles[5]        = { "", "x", "xy", "xyz", "xyzw" };
 751         static const char* s_rotSwizzles[5]     = { "", "x", "yx", "yzx", "yzwx" };
 752
 753         map<string, string> params;
 754         params.insert(pair<string, string>("VAR_TYPE", getDataTypeName(varType)));
 755         params.insert(pair<string, string>("PRECISION", "mediump"));
 756         params.insert(pair<string, string>("SWIZZLE", s_swizzles[vecLen]));
 757         params.insert(pair<string, string>("ROT_SWIZZLE", s_rotSwizzles[vecLen]));
 758
 759         StringTemplate vertTemplate(vtx.str().c_str());
 760         StringTemplate fragTemplate(frag.str().c_str());
 761         string vertexShaderSource = vertTemplate.specialize(params);
 762         string fragmentShaderSource = fragTemplate.specialize(params);
 763
 764         ShaderEvalFunc evalFunc = getVectorSubscriptEvalFunc(varType);
 765         return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
 766 }
 767
 768 // MATRIX SUBSCRIPT.
 769
 770 void evalSubscriptMat2          (ShaderEvalContext& c) { c.color.xy()   = c.coords.swizzle(0,1) + 0.5f*c.coords.swizzle(1,2); }
 771 void evalSubscriptMat2x3        (ShaderEvalContext& c) { c.color.xyz()  = c.coords.swizzle(0,1,2) + 0.5f*c.coords.swizzle(1,2,3); }
 772 void evalSubscriptMat2x4        (ShaderEvalContext& c) { c.color                = c.coords.swizzle(0,1,2,3) + 0.5f*c.coords.swizzle(1,2,3,0); }
 773
 774 void evalSubscriptMat3x2        (ShaderEvalContext& c) { c.color.xy()   = c.coords.swizzle(0,1) + 0.5f*c.coords.swizzle(1,2) + 0.25f*c.coords.swizzle(2,3); }
 775 void evalSubscriptMat3          (ShaderEvalContext& c) { c.color.xyz()  = c.coords.swizzle(0,1,2) + 0.5f*c.coords.swizzle(1,2,3) + 0.25f*c.coords.swizzle(2,3,0); }
 776 void evalSubscriptMat3x4        (ShaderEvalContext& c) { c.color                = c.coords.swizzle(0,1,2,3) + 0.5f*c.coords.swizzle(1,2,3,0) + 0.25f*c.coords.swizzle(2,3,0,1); }
 777
 778 void evalSubscriptMat4x2        (ShaderEvalContext& c) { c.color.xy()   = c.coords.swizzle(0,1) + 0.5f*c.coords.swizzle(1,2) + 0.25f*c.coords.swizzle(2,3) + 0.125f*c.coords.swizzle(3,0); }
 779 void evalSubscriptMat4x3        (ShaderEvalContext& c) { c.color.xyz()  = c.coords.swizzle(0,1,2) + 0.5f*c.coords.swizzle(1,2,3) + 0.25f*c.coords.swizzle(2,3,0) + 0.125f*c.coords.swizzle(3,0,1); }
 780 void evalSubscriptMat4          (ShaderEvalContext& c) { c.color                = c.coords + 0.5f*c.coords.swizzle(1,2,3,0) + 0.25f*c.coords.swizzle(2,3,0,1) + 0.125f*c.coords.swizzle(3,0,1,2); }
 781
 782 static ShaderEvalFunc getMatrixSubscriptEvalFunc (DataType dataType)
 783 {
 784         switch (dataType)
 785         {
 786                 case TYPE_FLOAT_MAT2:           return evalSubscriptMat2;
 787                 case TYPE_FLOAT_MAT2X3:         return evalSubscriptMat2x3;
 788                 case TYPE_FLOAT_MAT2X4:         return evalSubscriptMat2x4;
 789                 case TYPE_FLOAT_MAT3X2:         return evalSubscriptMat3x2;
 790                 case TYPE_FLOAT_MAT3:           return evalSubscriptMat3;
 791                 case TYPE_FLOAT_MAT3X4:         return evalSubscriptMat3x4;
 792                 case TYPE_FLOAT_MAT4X2:         return evalSubscriptMat4x2;
 793                 case TYPE_FLOAT_MAT4X3:         return evalSubscriptMat4x3;
 794                 case TYPE_FLOAT_MAT4:           return evalSubscriptMat4;
 795
 796                 default:
 797                         DE_FATAL("Invalid data type.");
 798                         return DE_NULL;
 799         }
 800 }
 801
 802 static ShaderIndexingCase* createMatrixSubscriptCase (Context& context, const char* caseName, const char* description, bool isVertexCase, DataType varType, IndexAccessType writeAccess, IndexAccessType readAccess)
 803 {
 804         std::ostringstream vtx;
 805         std::ostringstream frag;
 806         std::ostringstream& op = isVertexCase ? vtx : frag;
 807
 808         int                     numCols         = getDataTypeMatrixNumColumns(varType);
 809         int                     numRows         = getDataTypeMatrixNumRows(varType);
 810         const char*     matSizeName     = getIntUniformName(numCols);
 811         DataType        vecType         = getDataTypeFloatVec(numRows);
 812
 813         vtx << "#version 300 es\n";
 814         frag << "#version 300 es\n";
 815
 816         vtx << "in highp vec4 a_position;\n";
 817         vtx << "in highp vec4 a_coords;\n";
 818         frag << "layout(location = 0) out mediump vec4 o_color;\n";
 819
 820         if (isVertexCase)
 821         {
 822                 vtx << "out mediump vec4 v_color;\n";
 823                 frag << "in mediump vec4 v_color;\n";
 824         }
 825         else
 826         {
 827                 vtx << "out mediump vec4 v_coords;\n";
 828                 frag << "in mediump vec4 v_coords;\n";
 829         }
 830
 831         if (writeAccess == INDEXACCESS_DYNAMIC || readAccess == INDEXACCESS_DYNAMIC)
 832         {
 833                 op << "uniform mediump int ui_zero";
 834                 if (numCols >= 2) op << ", ui_one";
 835                 if (numCols >= 3) op << ", ui_two";
 836                 if (numCols >= 4) op << ", ui_three";
 837                 op << ";\n";
 838         }
 839
 840         if (writeAccess == INDEXACCESS_DYNAMIC_LOOP || readAccess == INDEXACCESS_DYNAMIC_LOOP)
 841                 op << "uniform mediump int " << matSizeName << ";\n";
 842
 843         vtx << "\n";
 844         vtx << "void main()\n";
 845         vtx << "{\n";
 846         vtx << "        gl_Position = a_position;\n";
 847
 848         frag << "\n";
 849         frag << "void main()\n";
 850         frag << "{\n";
 851
 852         // Write matrix.
 853         if (isVertexCase)
 854                 op << " ${PRECISION} vec4 coords = a_coords;\n";
 855         else
 856                 op << " ${PRECISION} vec4 coords = v_coords;\n";
 857
 858         op << " ${PRECISION} ${MAT_TYPE} tmp;\n";
 859         if (writeAccess == INDEXACCESS_STATIC)
 860         {
 861                 op << " tmp[0] = ${VEC_TYPE}(coords);\n";
 862                 if (numCols >= 2) op << "       tmp[1] = ${VEC_TYPE}(coords.yzwx) * 0.5;\n";
 863                 if (numCols >= 3) op << "       tmp[2] = ${VEC_TYPE}(coords.zwxy) * 0.25;\n";
 864                 if (numCols >= 4) op << "       tmp[3] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n";
 865         }
 866         else if (writeAccess == INDEXACCESS_DYNAMIC)
 867         {
 868                 op << " tmp[ui_zero]  = ${VEC_TYPE}(coords);\n";
 869                 if (numCols >= 2) op << "       tmp[ui_one]   = ${VEC_TYPE}(coords.yzwx) * 0.5;\n";
 870                 if (numCols >= 3) op << "       tmp[ui_two]   = ${VEC_TYPE}(coords.zwxy) * 0.25;\n";
 871                 if (numCols >= 4) op << "       tmp[ui_three] = ${VEC_TYPE}(coords.wxyz) * 0.125;\n";
 872         }
 873         else if (writeAccess == INDEXACCESS_STATIC_LOOP)
 874         {
 875                 op << " for (int i = 0; i < " << numCols << "; i++)\n";
 876                 op << " {\n";
 877                 op << "         tmp[i] = ${VEC_TYPE}(coords);\n";
 878                 op << "         coords = coords.yzwx * 0.5;\n";
 879                 op << " }\n";
 880         }
 881         else
 882         {
 883                 DE_ASSERT(writeAccess == INDEXACCESS_DYNAMIC_LOOP);
 884                 op << " for (int i = 0; i < " << matSizeName << "; i++)\n";
 885                 op << " {\n";
 886                 op << "         tmp[i] = ${VEC_TYPE}(coords);\n";
 887                 op << "         coords = coords.yzwx * 0.5;\n";
 888                 op << " }\n";
 889         }
 890
 891         // Read matrix.
 892         op << " ${PRECISION} ${VEC_TYPE} res = ${VEC_TYPE}(0.0);\n";
 893         if (readAccess == INDEXACCESS_STATIC)
 894         {
 895                 op << " res += tmp[0];\n";
 896                 if (numCols >= 2) op << "       res += tmp[1];\n";
 897                 if (numCols >= 3) op << "       res += tmp[2];\n";
 898                 if (numCols >= 4) op << "       res += tmp[3];\n";
 899         }
 900         else if (readAccess == INDEXACCESS_DYNAMIC)
 901         {
 902                 op << " res += tmp[ui_zero];\n";
 903                 if (numCols >= 2) op << "       res += tmp[ui_one];\n";
 904                 if (numCols >= 3) op << "       res += tmp[ui_two];\n";
 905                 if (numCols >= 4) op << "       res += tmp[ui_three];\n";
 906         }
 907         else if (readAccess == INDEXACCESS_STATIC_LOOP)
 908         {
 909                 op << " for (int i = 0; i < " << numCols << "; i++)\n";
 910                 op << "         res += tmp[i];\n";
 911         }
 912         else
 913         {
 914                 DE_ASSERT(readAccess == INDEXACCESS_DYNAMIC_LOOP);
 915                 op << " for (int i = 0; i < " << matSizeName << "; i++)\n";
 916                 op << "         res += tmp[i];\n";
 917         }
 918
 919         if (isVertexCase)
 920         {
 921                 vtx << "        v_color = vec4(res${PADDING});\n";
 922                 frag << "       o_color = v_color;\n";
 923         }
 924         else
 925         {
 926                 vtx << "        v_coords = a_coords;\n";
 927                 frag << "       o_color = vec4(res${PADDING});\n";
 928         }
 929
 930         vtx << "}\n";
 931         frag << "}\n";
 932
 933         // Fill in shader templates.
 934         map<string, string> params;
 935         params.insert(pair<string, string>("MAT_TYPE", getDataTypeName(varType)));
 936         params.insert(pair<string, string>("VEC_TYPE", getDataTypeName(vecType)));
 937         params.insert(pair<string, string>("PRECISION", "mediump"));
 938
 939         if (numRows == 2)
 940                 params.insert(pair<string, string>("PADDING", ", 0.0, 1.0"));
 941         else if (numRows == 3)
 942                 params.insert(pair<string, string>("PADDING", ", 1.0"));
 943         else
 944                 params.insert(pair<string, string>("PADDING", ""));
 945
 946         StringTemplate vertTemplate(vtx.str().c_str());
 947         StringTemplate fragTemplate(frag.str().c_str());
 948         string vertexShaderSource = vertTemplate.specialize(params);
 949         string fragmentShaderSource = fragTemplate.specialize(params);
 950
 951         ShaderEvalFunc evalFunc = getMatrixSubscriptEvalFunc(varType);
 952         return new ShaderIndexingCase(context, caseName, description, isVertexCase, varType, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
 953 }
 954
 955 // ShaderIndexingTests.
 956
 957 ShaderIndexingTests::ShaderIndexingTests(Context& context)
 958         : TestCaseGroup(context, "indexing", "Indexing Tests")
 959 {
 960 }
 961
 962 ShaderIndexingTests::~ShaderIndexingTests (void)
 963 {
 964 }
 965
 966 void ShaderIndexingTests::init (void)
 967 {
 968         static const ShaderType s_shaderTypes[] =
 969         {
 970                 SHADERTYPE_VERTEX,
 971                 SHADERTYPE_FRAGMENT
 972         };
 973
 974         static const DataType s_floatAndVecTypes[] =
 975         {
 976                 TYPE_FLOAT,
 977                 TYPE_FLOAT_VEC2,
 978                 TYPE_FLOAT_VEC3,
 979                 TYPE_FLOAT_VEC4
 980         };
 981
 982         // Varying array access cases.
 983         {
 984                 TestCaseGroup* varyingGroup = new TestCaseGroup(m_context, "varying_array", "Varying array access tests.");
 985                 addChild(varyingGroup);
 986
 987                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++)
 988                 {
 989                         DataType varType = s_floatAndVecTypes[typeNdx];
 990                         for (int vertAccess = 0; vertAccess < INDEXACCESS_LAST; vertAccess++)
 991                         {
 992                                 for (int fragAccess = 0; fragAccess < INDEXACCESS_LAST; fragAccess++)
 993                                 {
 994                                         const char* vertAccessName = getIndexAccessTypeName((IndexAccessType)vertAccess);
 995                                         const char* fragAccessName = getIndexAccessTypeName((IndexAccessType)fragAccess);
 996                                         string name = string(getDataTypeName(varType)) + "_" + vertAccessName + "_write_" + fragAccessName + "_read";
 997                                         string desc = string("Varying array with ") + vertAccessName + " write in vertex shader and " + fragAccessName + " read in fragment shader.";
 998                                         varyingGroup->addChild(createVaryingArrayCase(m_context, name.c_str(), desc.c_str(), varType, (IndexAccessType)vertAccess, (IndexAccessType)fragAccess));
 999                                 }
1000                         }
1001                 }
1002         }
1003
1004         // Uniform array access cases.
1005         {
1006                 TestCaseGroup* uniformGroup = new TestCaseGroup(m_context, "uniform_array", "Uniform array access tests.");
1007                 addChild(uniformGroup);
1008
1009                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++)
1010                 {
1011                         DataType varType = s_floatAndVecTypes[typeNdx];
1012                         for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++)
1013                         {
1014                                 const char* readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess);
1015                                 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1016                                 {
1017                                         ShaderType      shaderType              = s_shaderTypes[shaderTypeNdx];
1018                                         const char*     shaderTypeName  = getShaderTypeName(shaderType);
1019                                         string          name                    = string(getDataTypeName(varType)) + "_" + readAccessName + "_read_" + shaderTypeName;
1020                                         string          desc                    = string("Uniform array with ") + readAccessName + " read in " + shaderTypeName + " shader.";
1021                                         bool isVertexCase = ((ShaderType)shaderType == SHADERTYPE_VERTEX);
1022                                         uniformGroup->addChild(createUniformArrayCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, (IndexAccessType)readAccess));
1023                                 }
1024                         }
1025                 }
1026         }
1027
1028         // Temporary array access cases.
1029         {
1030                 TestCaseGroup* tmpGroup = new TestCaseGroup(m_context, "tmp_array", "Temporary array access tests.");
1031                 addChild(tmpGroup);
1032
1033                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_floatAndVecTypes); typeNdx++)
1034                 {
1035                         DataType varType = s_floatAndVecTypes[typeNdx];
1036                         for (int writeAccess = 0; writeAccess < INDEXACCESS_LAST; writeAccess++)
1037                         {
1038                                 for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++)
1039                                 {
1040                                         const char* writeAccessName = getIndexAccessTypeName((IndexAccessType)writeAccess);
1041                                         const char* readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess);
1042
1043                                         for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1044                                         {
1045                                                 ShaderType      shaderType              = s_shaderTypes[shaderTypeNdx];
1046                                                 const char* shaderTypeName      = getShaderTypeName(shaderType);
1047                                                 string          name                    = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
1048                                                 string          desc                    = string("Temporary array with ") + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
1049                                                 bool            isVertexCase    = ((ShaderType)shaderType == SHADERTYPE_VERTEX);
1050                                                 tmpGroup->addChild(createTmpArrayCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, (IndexAccessType)writeAccess, (IndexAccessType)readAccess));
1051                                         }
1052                                 }
1053                         }
1054                 }
1055         }
1056
1057         // Vector indexing with subscripts.
1058         {
1059                 TestCaseGroup* vecGroup = new TestCaseGroup(m_context, "vector_subscript", "Vector subscript indexing.");
1060                 addChild(vecGroup);
1061
1062                 static const DataType s_vectorTypes[] =
1063                 {
1064                         TYPE_FLOAT_VEC2,
1065                         TYPE_FLOAT_VEC3,
1066                         TYPE_FLOAT_VEC4
1067                 };
1068
1069                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_vectorTypes); typeNdx++)
1070                 {
1071                         DataType varType = s_vectorTypes[typeNdx];
1072                         for (int writeAccess = 0; writeAccess < VECTORACCESS_LAST; writeAccess++)
1073                         {
1074                                 for (int readAccess = 0; readAccess < VECTORACCESS_LAST; readAccess++)
1075                                 {
1076                                         const char* writeAccessName = getVectorAccessTypeName((VectorAccessType)writeAccess);
1077                                         const char* readAccessName = getVectorAccessTypeName((VectorAccessType)readAccess);
1078
1079                                         for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1080                                         {
1081                                                 ShaderType      shaderType              = s_shaderTypes[shaderTypeNdx];
1082                                                 const char* shaderTypeName      = getShaderTypeName(shaderType);
1083                                                 string          name                    = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
1084                                                 string          desc                    = string("Vector subscript access with ") + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
1085                                                 bool            isVertexCase    = ((ShaderType)shaderType == SHADERTYPE_VERTEX);
1086                                                 vecGroup->addChild(createVectorSubscriptCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, (VectorAccessType)writeAccess, (VectorAccessType)readAccess));
1087                                         }
1088                                 }
1089                         }
1090                 }
1091         }
1092
1093         // Matrix indexing with subscripts.
1094         {
1095                 TestCaseGroup* matGroup = new TestCaseGroup(m_context, "matrix_subscript", "Matrix subscript indexing.");
1096                 addChild(matGroup);
1097
1098                 static const DataType s_matrixTypes[] =
1099                 {
1100                         TYPE_FLOAT_MAT2,
1101                         TYPE_FLOAT_MAT2X3,
1102                         TYPE_FLOAT_MAT2X4,
1103                         TYPE_FLOAT_MAT3X2,
1104                         TYPE_FLOAT_MAT3,
1105                         TYPE_FLOAT_MAT3X4,
1106                         TYPE_FLOAT_MAT4X2,
1107                         TYPE_FLOAT_MAT4X3,
1108                         TYPE_FLOAT_MAT4
1109                 };
1110
1111                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_matrixTypes); typeNdx++)
1112                 {
1113                         DataType varType = s_matrixTypes[typeNdx];
1114                         for (int writeAccess = 0; writeAccess < INDEXACCESS_LAST; writeAccess++)
1115                         {
1116                                 for (int readAccess = 0; readAccess < INDEXACCESS_LAST; readAccess++)
1117                                 {
1118                                         const char* writeAccessName = getIndexAccessTypeName((IndexAccessType)writeAccess);
1119                                         const char* readAccessName = getIndexAccessTypeName((IndexAccessType)readAccess);
1120
1121                                         for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
1122                                         {
1123                                                 ShaderType      shaderType              = s_shaderTypes[shaderTypeNdx];
1124                                                 const char* shaderTypeName      = getShaderTypeName(shaderType);
1125                                                 string          name                    = string(getDataTypeName(varType)) + "_" + writeAccessName + "_write_" + readAccessName + "_read_" + shaderTypeName;
1126                                                 string          desc                    = string("Vector subscript access with ") + writeAccessName + " write and " + readAccessName + " read in " + shaderTypeName + " shader.";
1127                                                 bool            isVertexCase    = ((ShaderType)shaderType == SHADERTYPE_VERTEX);
1128                                                 matGroup->addChild(createMatrixSubscriptCase(m_context, name.c_str(), desc.c_str(), isVertexCase, varType, (IndexAccessType)writeAccess, (IndexAccessType)readAccess));
1129                                         }
1130                                 }
1131                         }
1132                 }
1133         }
1134 }
1135
1136 } // Functional
1137 } // gles3
1138 } // deqp