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