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