1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Instanced rendering tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "es3fInstancedRenderingTests.hpp"
25#include "gluPixelTransfer.hpp"
26#include "gluShaderProgram.hpp"
27#include "gluShaderUtil.hpp"
28#include "tcuTestLog.hpp"
29#include "tcuSurface.hpp"
30#include "tcuImageCompare.hpp"
31#include "tcuVector.hpp"
32#include "tcuRenderTarget.hpp"
33#include "deRandom.hpp"
34#include "deStringUtil.hpp"
35#include "deString.h"
36
37#include "glw.h"
38
39using std::vector;
40using std::string;
41
42namespace deqp
43{
44namespace gles3
45{
46namespace Functional
47{
48
49static const int	MAX_RENDER_WIDTH		= 128;
50static const int	MAX_RENDER_HEIGHT		= 128;
51
52static const int	QUAD_GRID_SIZE			= 127;
53
54// Attribute divisors for the attributes defining the color's RGB components.
55static const int	ATTRIB_DIVISOR_R		= 3;
56static const int	ATTRIB_DIVISOR_G		= 2;
57static const int	ATTRIB_DIVISOR_B		= 1;
58
59static const int	OFFSET_COMPONENTS		= 3; // \note Affects whether a float or a vecN is used in shader, but only first component is non-zero.
60
61// Scale and bias values when converting float to integer, when attribute is of integer type.
62static const float	FLOAT_INT_SCALE			= 100.0f;
63static const float	FLOAT_INT_BIAS			= -50.0f;
64static const float	FLOAT_UINT_SCALE		= 100.0f;
65static const float	FLOAT_UINT_BIAS			= 0.0f;
66
67// \note Non-anonymous namespace needed; VarComp is used as a template parameter.
68namespace vcns
69{
70
71union VarComp
72{
73	float		f32;
74	deUint32	u32;
75	deInt32		i32;
76
77	VarComp(float v)	: f32(v) {}
78	VarComp(deUint32 v)	: u32(v) {}
79	VarComp(deInt32 v)	: i32(v) {}
80};
81DE_STATIC_ASSERT(sizeof(VarComp) == sizeof(deUint32));
82
83} // vcns
84
85using namespace vcns;
86
87class InstancedRenderingCase : public TestCase
88{
89public:
90	enum DrawFunction
91	{
92		FUNCTION_DRAW_ARRAYS_INSTANCED = 0,
93		FUNCTION_DRAW_ELEMENTS_INSTANCED,
94
95		FUNCTION_LAST
96	};
97
98	enum InstancingType
99	{
100		TYPE_INSTANCE_ID = 0,
101		TYPE_ATTRIB_DIVISOR,
102		TYPE_MIXED,
103
104		TYPE_LAST
105	};
106
107								InstancedRenderingCase	(Context& context, const char* name, const char* description, DrawFunction function, InstancingType instancingType, glu::DataType rgbAttrType, int numInstances);
108								~InstancedRenderingCase	(void);
109
110	void						init					(void);
111	void						deinit					(void);
112	IterateResult				iterate					(void);
113
114private:
115								InstancedRenderingCase	(const InstancedRenderingCase& other);
116	InstancedRenderingCase&		operator=				(const InstancedRenderingCase& other);
117
118	void						pushVarCompAttrib		(vector<VarComp>& vec, float val);
119
120	void						setupVarAttribPointer	(const void* attrPtr, int startLocation, int divisor);
121	void						setupAndRender			(void);
122	void						computeReference		(tcu::Surface& dst);
123
124	DrawFunction				m_function;
125	InstancingType				m_instancingType;
126	glu::DataType				m_rgbAttrType;			// \note Instance attribute types, color components only. Position offset attribute is always float/vecN.
127	int							m_numInstances;
128
129	vector<float>				m_gridVertexPositions;	// X and Y components per vertex.
130	vector<deUint16>			m_gridIndices;			// \note Only used if m_function is FUNCTION_DRAW_ELEMENTS_INSTANCED.
131
132	// \note Some or all of the following instance attribute parameters may be unused with TYPE_INSTANCE_ID or TYPE_MIXED.
133	vector<float>				m_instanceOffsets;		// Position offsets. OFFSET_COMPONENTS components per offset.
134	// Attribute data for float, int or uint (or respective vector types) color components.
135	vector<VarComp>				m_instanceColorR;
136	vector<VarComp>				m_instanceColorG;
137	vector<VarComp>				m_instanceColorB;
138
139	glu::ShaderProgram*			m_program;
140};
141
142InstancedRenderingCase::InstancedRenderingCase (Context& context, const char* name, const char* description, DrawFunction function, InstancingType instancingType, glu::DataType rgbAttrType, int numInstances)
143	: TestCase			(context, name, description)
144	, m_function		(function)
145	, m_instancingType	(instancingType)
146	, m_rgbAttrType		(rgbAttrType)
147	, m_numInstances	(numInstances)
148	, m_program			(DE_NULL)
149{
150}
151
152InstancedRenderingCase::~InstancedRenderingCase (void)
153{
154	InstancedRenderingCase::deinit();
155}
156
157// Helper function that does biasing and scaling when converting float to integer.
158void InstancedRenderingCase::pushVarCompAttrib (vector<VarComp>& vec, float val)
159{
160	bool	isFloatCase	= glu::isDataTypeFloatOrVec(m_rgbAttrType);
161	bool	isIntCase	= glu::isDataTypeIntOrIVec(m_rgbAttrType);
162	bool	isUintCase	= glu::isDataTypeUintOrUVec(m_rgbAttrType);
163	bool	isMatCase	= glu::isDataTypeMatrix(m_rgbAttrType);
164
165	if (isFloatCase || isMatCase)
166		vec.push_back(VarComp(val));
167	else if (isIntCase)
168		vec.push_back(VarComp((deInt32)(val*FLOAT_INT_SCALE + FLOAT_INT_BIAS)));
169	else if (isUintCase)
170		vec.push_back(VarComp((deUint32)(val*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS)));
171	else
172		DE_ASSERT(DE_FALSE);
173}
174
175void InstancedRenderingCase::init (void)
176{
177	bool	isFloatCase			= glu::isDataTypeFloatOrVec(m_rgbAttrType);
178	bool	isIntCase			= glu::isDataTypeIntOrIVec(m_rgbAttrType);
179	bool	isUintCase			= glu::isDataTypeUintOrUVec(m_rgbAttrType);
180	bool	isMatCase			= glu::isDataTypeMatrix(m_rgbAttrType);
181	int		typeSize			= glu::getDataTypeScalarSize(m_rgbAttrType);
182	bool	isScalarCase		= typeSize == 1;
183	string	swizzleFirst		= isScalarCase ? "" : ".x";
184	string	typeName			= glu::getDataTypeName(m_rgbAttrType);
185
186	string	floatIntScaleStr	= "(" + de::floatToString(FLOAT_INT_SCALE, 3) + ")";
187	string	floatIntBiasStr		= "(" + de::floatToString(FLOAT_INT_BIAS, 3) + ")";
188	string	floatUintScaleStr	= "(" + de::floatToString(FLOAT_UINT_SCALE, 3) + ")";
189	string	floatUintBiasStr	= "(" + de::floatToString(FLOAT_UINT_BIAS, 3) + ")";
190
191	DE_ASSERT(isFloatCase || isIntCase || isUintCase || isMatCase);
192
193	// Generate shader.
194	// \note For case TYPE_MIXED, vertex position offset and color red component get their values from instance id, while green and blue get their values from instanced attributes.
195
196	string numInstancesStr = de::toString(m_numInstances) + ".0";
197
198	string instanceAttribs;
199	string posExpression;
200	string colorRExpression;
201	string colorGExpression;
202	string colorBExpression;
203
204	if (m_instancingType == TYPE_INSTANCE_ID || m_instancingType == TYPE_MIXED)
205	{
206		posExpression = "a_position + vec4(float(gl_InstanceID) * 2.0 / " + numInstancesStr + ", 0.0, 0.0, 0.0)";
207		colorRExpression = "float(gl_InstanceID)/" + numInstancesStr;
208
209		if (m_instancingType == TYPE_INSTANCE_ID)
210		{
211			colorGExpression = "float(gl_InstanceID)*2.0/" + numInstancesStr;
212			colorBExpression = "1.0 - float(gl_InstanceID)/" + numInstancesStr;
213		}
214	}
215
216	if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
217	{
218		if (m_instancingType == TYPE_ATTRIB_DIVISOR)
219		{
220			posExpression = "a_position + vec4(a_instanceOffset";
221
222			DE_STATIC_ASSERT(OFFSET_COMPONENTS >= 1 && OFFSET_COMPONENTS <= 4);
223
224			for (int i = 0; i < 4-OFFSET_COMPONENTS; i++)
225				posExpression += ", 0.0";
226			posExpression += ")";
227
228			if (isFloatCase)
229				colorRExpression = "a_instanceR" + swizzleFirst;
230			else if (isIntCase)
231				colorRExpression = "(float(a_instanceR" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
232			else if (isUintCase)
233				colorRExpression = "(float(a_instanceR" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
234			else if (isMatCase)
235				colorRExpression = "a_instanceR[0][0]";
236			else
237				DE_ASSERT(DE_FALSE);
238
239			instanceAttribs += "in highp " + (OFFSET_COMPONENTS == 1 ? string("float") : "vec" + de::toString(OFFSET_COMPONENTS)) + " a_instanceOffset;\n";
240			instanceAttribs += "in mediump " + typeName + " a_instanceR;\n";
241		}
242
243		if (isFloatCase)
244		{
245			colorGExpression = "a_instanceG" + swizzleFirst;
246			colorBExpression = "a_instanceB" + swizzleFirst;
247		}
248		else if (isIntCase)
249		{
250			colorGExpression = "(float(a_instanceG" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
251			colorBExpression = "(float(a_instanceB" + swizzleFirst + ") - " + floatIntBiasStr + ") / " + floatIntScaleStr;
252		}
253		else if (isUintCase)
254		{
255			colorGExpression = "(float(a_instanceG" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
256			colorBExpression = "(float(a_instanceB" + swizzleFirst + ") - " + floatUintBiasStr + ") / " + floatUintScaleStr;
257		}
258		else if (isMatCase)
259		{
260			colorGExpression = "a_instanceG[0][0]";
261			colorBExpression = "a_instanceB[0][0]";
262		}
263		else
264			DE_ASSERT(DE_FALSE);
265
266		instanceAttribs += "in mediump " + typeName + " a_instanceG;\n";
267		instanceAttribs += "in mediump " + typeName + " a_instanceB;\n";
268	}
269
270	DE_ASSERT(!posExpression.empty());
271	DE_ASSERT(!colorRExpression.empty());
272	DE_ASSERT(!colorGExpression.empty());
273	DE_ASSERT(!colorBExpression.empty());
274
275	std::string vertShaderSourceStr =
276		"#version 300 es\n"
277		"in highp vec4 a_position;\n" +
278		instanceAttribs +
279		"out mediump vec4 v_color;\n"
280		"\n"
281		"void main()\n"
282		"{\n"
283		"	gl_Position = " + posExpression + ";\n"
284		"	v_color.r = " + colorRExpression + ";\n"
285		"	v_color.g = " + colorGExpression + ";\n"
286		"	v_color.b = " + colorBExpression + ";\n"
287		"	v_color.a = 1.0;\n"
288		"}\n";
289
290	static const char* fragShaderSource =
291		"#version 300 es\n"
292		"layout(location = 0) out mediump vec4 o_color;\n"
293		"in mediump vec4 v_color;\n"
294		"\n"
295		"void main()\n"
296		"{\n"
297		"	o_color = v_color;\n"
298		"}\n";
299
300	// Create shader program and log it.
301
302	DE_ASSERT(!m_program);
303	m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertShaderSourceStr, fragShaderSource));
304
305	tcu::TestLog& log = m_testCtx.getLog();
306
307	log << *m_program;
308
309	if(!m_program->isOk())
310		TCU_FAIL("Failed to compile shader");
311
312	// Vertex shader attributes.
313
314	if (m_function == FUNCTION_DRAW_ELEMENTS_INSTANCED)
315	{
316		// Vertex positions. Positions form a vertical bar of width <screen width>/<number of instances>.
317
318		for (int y = 0; y < QUAD_GRID_SIZE + 1; y++)
319			for (int x = 0; x < QUAD_GRID_SIZE + 1; x++)
320			{
321				float fx = -1.0f + (float)x / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
322				float fy = -1.0f + (float)y / (float)QUAD_GRID_SIZE * 2.0f;
323
324				m_gridVertexPositions.push_back(fx);
325				m_gridVertexPositions.push_back(fy);
326			}
327
328		// Indices.
329
330		for (int y = 0; y < QUAD_GRID_SIZE; y++)
331			for (int x = 0; x < QUAD_GRID_SIZE; x++)
332			{
333				int ndx00 = y*(QUAD_GRID_SIZE + 1) + x;
334				int ndx10 = y*(QUAD_GRID_SIZE + 1) + x + 1;
335				int ndx01 = (y + 1)*(QUAD_GRID_SIZE + 1) + x;
336				int ndx11 = (y + 1)*(QUAD_GRID_SIZE + 1) + x + 1;
337
338				// Lower-left triangle of a quad.
339				m_gridIndices.push_back((deUint16)ndx00);
340				m_gridIndices.push_back((deUint16)ndx10);
341				m_gridIndices.push_back((deUint16)ndx01);
342
343				// Upper-right triangle of a quad.
344				m_gridIndices.push_back((deUint16)ndx11);
345				m_gridIndices.push_back((deUint16)ndx01);
346				m_gridIndices.push_back((deUint16)ndx10);
347			}
348	}
349	else
350	{
351		DE_ASSERT(m_function == FUNCTION_DRAW_ARRAYS_INSTANCED);
352
353		// Vertex positions. Positions form a vertical bar of width <screen width>/<number of instances>.
354
355		for (int y = 0; y < QUAD_GRID_SIZE; y++)
356			for (int x = 0; x < QUAD_GRID_SIZE; x++)
357			{
358				float fx0 = -1.0f + (float)(x+0) / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
359				float fx1 = -1.0f + (float)(x+1) / (float)QUAD_GRID_SIZE * 2.0f / (float)m_numInstances;
360				float fy0 = -1.0f + (float)(y+0) / (float)QUAD_GRID_SIZE * 2.0f;
361				float fy1 = -1.0f + (float)(y+1) / (float)QUAD_GRID_SIZE * 2.0f;
362
363				// Vertices of a quad's lower-left triangle: (fx0, fy0), (fx1, fy0) and (fx0, fy1)
364				m_gridVertexPositions.push_back(fx0);
365				m_gridVertexPositions.push_back(fy0);
366				m_gridVertexPositions.push_back(fx1);
367				m_gridVertexPositions.push_back(fy0);
368				m_gridVertexPositions.push_back(fx0);
369				m_gridVertexPositions.push_back(fy1);
370
371				// Vertices of a quad's upper-right triangle: (fx1, fy1), (fx0, fy1) and (fx1, fy0)
372				m_gridVertexPositions.push_back(fx1);
373				m_gridVertexPositions.push_back(fy1);
374				m_gridVertexPositions.push_back(fx0);
375				m_gridVertexPositions.push_back(fy1);
376				m_gridVertexPositions.push_back(fx1);
377				m_gridVertexPositions.push_back(fy0);
378			}
379	}
380
381	// Instanced attributes: position offset and color RGB components.
382
383	if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
384	{
385		if (m_instancingType == TYPE_ATTRIB_DIVISOR)
386		{
387			// Offsets are such that the vertical bars are drawn next to each other.
388			for (int i = 0; i < m_numInstances; i++)
389			{
390				m_instanceOffsets.push_back((float)i * 2.0f / (float)m_numInstances);
391
392				DE_STATIC_ASSERT(OFFSET_COMPONENTS >= 1 && OFFSET_COMPONENTS <= 4);
393
394				for (int j = 0; j < OFFSET_COMPONENTS-1; j++)
395					m_instanceOffsets.push_back(0.0f);
396			}
397
398			int rInstances = m_numInstances / ATTRIB_DIVISOR_R + (m_numInstances % ATTRIB_DIVISOR_R == 0 ? 0 : 1);
399			for (int i = 0; i < rInstances; i++)
400			{
401				pushVarCompAttrib(m_instanceColorR, (float)i / (float)rInstances);
402
403				for (int j = 0; j < typeSize - 1; j++)
404					pushVarCompAttrib(m_instanceColorR, 0.0f);
405			}
406		}
407
408		int gInstances = m_numInstances / ATTRIB_DIVISOR_G + (m_numInstances % ATTRIB_DIVISOR_G == 0 ? 0 : 1);
409		for (int i = 0; i < gInstances; i++)
410		{
411			pushVarCompAttrib(m_instanceColorG, (float)i*2.0f / (float)gInstances);
412
413			for (int j = 0; j < typeSize - 1; j++)
414				pushVarCompAttrib(m_instanceColorG, 0.0f);
415		}
416
417		int bInstances = m_numInstances / ATTRIB_DIVISOR_B + (m_numInstances % ATTRIB_DIVISOR_B == 0 ? 0 : 1);
418		for (int i = 0; i < bInstances; i++)
419		{
420			pushVarCompAttrib(m_instanceColorB, 1.0f - (float)i / (float)bInstances);
421
422			for (int j = 0; j < typeSize - 1; j++)
423				pushVarCompAttrib(m_instanceColorB, 0.0f);
424		}
425	}
426}
427
428void InstancedRenderingCase::deinit (void)
429{
430	delete m_program;
431	m_program = DE_NULL;
432}
433
434InstancedRenderingCase::IterateResult InstancedRenderingCase::iterate (void)
435{
436	int							width			= deMin32(m_context.getRenderTarget().getWidth(), MAX_RENDER_WIDTH);
437	int							height			= deMin32(m_context.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT);
438
439	int							xOffsetMax		= m_context.getRenderTarget().getWidth() - width;
440	int							yOffsetMax		= m_context.getRenderTarget().getHeight() - height;
441
442	de::Random					rnd				(deStringHash(getName()));
443
444	int							xOffset			= rnd.getInt(0, xOffsetMax);
445	int							yOffset			= rnd.getInt(0, yOffsetMax);
446	tcu::Surface				referenceImg	(width, height);
447	tcu::Surface				resultImg		(width, height);
448
449	// Draw result.
450
451	glViewport(xOffset, yOffset, width, height);
452
453	setupAndRender();
454
455	glu::readPixels(m_context.getRenderContext(), xOffset, yOffset, resultImg.getAccess());
456
457	// Compute reference.
458
459	computeReference(referenceImg);
460
461	// Compare.
462
463	bool testOk = tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", referenceImg, resultImg, 0.05f, tcu::COMPARE_LOG_RESULT);
464
465	m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
466							testOk ? "Pass"					: "Fail");
467
468	return STOP;
469}
470
471void InstancedRenderingCase::setupVarAttribPointer (const void* attrPtr, int location, int divisor)
472{
473	bool	isFloatCase		= glu::isDataTypeFloatOrVec(m_rgbAttrType);
474	bool	isIntCase		= glu::isDataTypeIntOrIVec(m_rgbAttrType);
475	bool	isUintCase		= glu::isDataTypeUintOrUVec(m_rgbAttrType);
476	bool	isMatCase		= glu::isDataTypeMatrix(m_rgbAttrType);
477	int		typeSize		= glu::getDataTypeScalarSize(m_rgbAttrType);
478	int		numSlots		= isMatCase ? glu::getDataTypeMatrixNumColumns(m_rgbAttrType) : 1; // Matrix uses as many attribute slots as it has columns.
479
480	for (int slotNdx = 0; slotNdx < numSlots; slotNdx++)
481	{
482		int curLoc = location + slotNdx;
483
484		glEnableVertexAttribArray(curLoc);
485		glVertexAttribDivisor(curLoc, divisor);
486
487		if (isFloatCase)
488			glVertexAttribPointer(curLoc, typeSize, GL_FLOAT, GL_FALSE, 0, attrPtr);
489		else if (isIntCase)
490			glVertexAttribIPointer(curLoc, typeSize, GL_INT, 0, attrPtr);
491		else if (isUintCase)
492			glVertexAttribIPointer(curLoc, typeSize, GL_UNSIGNED_INT, 0, attrPtr);
493		else if (isMatCase)
494		{
495			int numRows = glu::getDataTypeMatrixNumRows(m_rgbAttrType);
496			int numCols = glu::getDataTypeMatrixNumColumns(m_rgbAttrType);
497
498			glVertexAttribPointer(curLoc, numRows, GL_FLOAT, GL_FALSE, numCols*numRows*(int)sizeof(float), attrPtr);
499		}
500		else
501			DE_ASSERT(DE_FALSE);
502	}
503}
504
505void InstancedRenderingCase::setupAndRender (void)
506{
507	deUint32 program = m_program->getProgram();
508
509	glUseProgram(program);
510
511	{
512		// Setup attributes.
513
514		// Position attribute is non-instanced.
515		int positionLoc = glGetAttribLocation(program, "a_position");
516		glEnableVertexAttribArray(positionLoc);
517		glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, &m_gridVertexPositions[0]);
518
519		if (m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED)
520		{
521			if (m_instancingType == TYPE_ATTRIB_DIVISOR)
522			{
523				// Position offset attribute is instanced with separate offset for every instance.
524				int offsetLoc = glGetAttribLocation(program, "a_instanceOffset");
525				glEnableVertexAttribArray(offsetLoc);
526				glVertexAttribDivisor(offsetLoc, 1);
527				glVertexAttribPointer(offsetLoc, OFFSET_COMPONENTS, GL_FLOAT, GL_FALSE, 0, &m_instanceOffsets[0]);
528
529				int rLoc = glGetAttribLocation(program, "a_instanceR");
530				setupVarAttribPointer((void*)&m_instanceColorR[0].u32, rLoc, ATTRIB_DIVISOR_R);
531			}
532
533			int gLoc = glGetAttribLocation(program, "a_instanceG");
534			setupVarAttribPointer((void*)&m_instanceColorG[0].u32, gLoc, ATTRIB_DIVISOR_G);
535
536			int bLoc = glGetAttribLocation(program, "a_instanceB");
537			setupVarAttribPointer((void*)&m_instanceColorB[0].u32, bLoc, ATTRIB_DIVISOR_B);
538		}
539	}
540
541	// Draw using appropriate function.
542
543	if (m_function == FUNCTION_DRAW_ARRAYS_INSTANCED)
544	{
545		const int numPositionComponents = 2;
546		glDrawArraysInstanced(GL_TRIANGLES, 0, ((int)m_gridVertexPositions.size() / numPositionComponents), m_numInstances);
547	}
548	else
549		glDrawElementsInstanced(GL_TRIANGLES, (int)m_gridIndices.size(), GL_UNSIGNED_SHORT, &m_gridIndices[0], m_numInstances);
550
551	glUseProgram(0);
552}
553
554void InstancedRenderingCase::computeReference (tcu::Surface& dst)
555{
556	int wid = dst.getWidth();
557	int hei = dst.getHeight();
558
559	// Draw a rectangle (vertical bar) for each instance.
560
561	for (int instanceNdx = 0; instanceNdx < m_numInstances; instanceNdx++)
562	{
563		int xStart		= instanceNdx * wid / m_numInstances;
564		int xEnd		= (instanceNdx + 1) * wid / m_numInstances;
565
566		// Emulate attribute divisors if that is the case.
567
568		int clrNdxR		= m_instancingType == TYPE_ATTRIB_DIVISOR									? instanceNdx / ATTRIB_DIVISOR_R : instanceNdx;
569		int clrNdxG		= m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED	? instanceNdx / ATTRIB_DIVISOR_G : instanceNdx;
570		int clrNdxB		= m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED	? instanceNdx / ATTRIB_DIVISOR_B : instanceNdx;
571
572		int rInstances	= m_instancingType == TYPE_ATTRIB_DIVISOR									? m_numInstances / ATTRIB_DIVISOR_R + (m_numInstances % ATTRIB_DIVISOR_R == 0 ? 0 : 1) : m_numInstances;
573		int gInstances	= m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED	? m_numInstances / ATTRIB_DIVISOR_G + (m_numInstances % ATTRIB_DIVISOR_G == 0 ? 0 : 1) : m_numInstances;
574		int bInstances	= m_instancingType == TYPE_ATTRIB_DIVISOR || m_instancingType == TYPE_MIXED	? m_numInstances / ATTRIB_DIVISOR_B + (m_numInstances % ATTRIB_DIVISOR_B == 0 ? 0 : 1) : m_numInstances;
575
576		// Calculate colors.
577
578		float r = (float)clrNdxR / (float)rInstances;
579		float g = (float)clrNdxG * 2.0f / (float)gInstances;
580		float b = 1.0f - (float)clrNdxB / (float)bInstances;
581
582		// Convert to integer and back if shader inputs are integers.
583
584		if (glu::isDataTypeIntOrIVec(m_rgbAttrType))
585		{
586			deInt32 intR = (deInt32)(r*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
587			deInt32 intG = (deInt32)(g*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
588			deInt32 intB = (deInt32)(b*FLOAT_INT_SCALE + FLOAT_INT_BIAS);
589			r = ((float)intR - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
590			g = ((float)intG - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
591			b = ((float)intB - FLOAT_INT_BIAS) / FLOAT_INT_SCALE;
592		}
593		else if(glu::isDataTypeUintOrUVec(m_rgbAttrType))
594		{
595			deUint32 uintR = (deInt32)(r*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
596			deUint32 uintG = (deInt32)(g*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
597			deUint32 uintB = (deInt32)(b*FLOAT_UINT_SCALE + FLOAT_UINT_BIAS);
598			r = ((float)uintR - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
599			g = ((float)uintG - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
600			b = ((float)uintB - FLOAT_UINT_BIAS) / FLOAT_UINT_SCALE;
601		}
602
603		// Draw rectangle.
604
605		for (int y = 0; y < hei; y++)
606			for (int x = xStart; x < xEnd; x++)
607				dst.setPixel(x, y, tcu::RGBA(tcu::Vec4(r, g, b, 1.0f)));
608	}
609}
610
611InstancedRenderingTests::InstancedRenderingTests (Context& context)
612	: TestCaseGroup(context, "instanced", "Instanced rendering tests")
613{
614}
615
616InstancedRenderingTests::~InstancedRenderingTests (void)
617{
618}
619
620void InstancedRenderingTests::init (void)
621{
622	// Cases testing function, instancing method and instance count.
623
624	static const int instanceCounts[] = { 1, 2, 4, 20 };
625
626	for (int function = 0; function < (int)InstancedRenderingCase::FUNCTION_LAST; function++)
627	{
628		const char* functionName = function == (int)InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED		? "draw_arrays_instanced"
629								 : function == (int)InstancedRenderingCase::FUNCTION_DRAW_ELEMENTS_INSTANCED	? "draw_elements_instanced"
630								 : DE_NULL;
631
632		const char* functionDesc = function == (int)InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED		? "Use glDrawArraysInstanced()"
633								 : function == (int)InstancedRenderingCase::FUNCTION_DRAW_ELEMENTS_INSTANCED	? "Use glDrawElementsInstanced()"
634								 : DE_NULL;
635
636		DE_ASSERT(functionName != DE_NULL);
637		DE_ASSERT(functionDesc != DE_NULL);
638
639		TestCaseGroup* functionGroup = new TestCaseGroup(m_context, functionName, functionDesc);
640		addChild(functionGroup);
641
642		for (int instancingType = 0; instancingType < (int)InstancedRenderingCase::TYPE_LAST; instancingType++)
643		{
644			const char* instancingTypeName = instancingType == (int)InstancedRenderingCase::TYPE_INSTANCE_ID	? "instance_id"
645										   : instancingType == (int)InstancedRenderingCase::TYPE_ATTRIB_DIVISOR	? "attribute_divisor"
646										   : instancingType == (int)InstancedRenderingCase::TYPE_MIXED			? "mixed"
647										   : DE_NULL;
648
649			const char* instancingTypeDesc = instancingType == (int)InstancedRenderingCase::TYPE_INSTANCE_ID	? "Use gl_InstanceID for instancing"
650										   : instancingType == (int)InstancedRenderingCase::TYPE_ATTRIB_DIVISOR	? "Use vertex attribute divisors for instancing"
651										   : instancingType == (int)InstancedRenderingCase::TYPE_MIXED			? "Use both gl_InstanceID and vertex attribute divisors for instancing"
652										   : DE_NULL;
653
654			DE_ASSERT(instancingTypeName != DE_NULL);
655			DE_ASSERT(instancingTypeDesc != DE_NULL);
656
657			TestCaseGroup* instancingTypeGroup = new TestCaseGroup(m_context, instancingTypeName, instancingTypeDesc);
658			functionGroup->addChild(instancingTypeGroup);
659
660			for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(instanceCounts); countNdx++)
661			{
662				std::string countName = de::toString(instanceCounts[countNdx]) + "_instances";
663
664				instancingTypeGroup->addChild(new InstancedRenderingCase(m_context, countName.c_str(), "",
665																		 (InstancedRenderingCase::DrawFunction)function,
666																		 (InstancedRenderingCase::InstancingType)instancingType,
667																		 glu::TYPE_FLOAT,
668																		 instanceCounts[countNdx]));
669			}
670		}
671	}
672
673	// Data type specific cases.
674
675	static const glu::DataType s_testTypes[] =
676	{
677		glu::TYPE_FLOAT,
678		glu::TYPE_FLOAT_VEC2,
679		glu::TYPE_FLOAT_VEC3,
680		glu::TYPE_FLOAT_VEC4,
681		glu::TYPE_FLOAT_MAT2,
682		glu::TYPE_FLOAT_MAT2X3,
683		glu::TYPE_FLOAT_MAT2X4,
684		glu::TYPE_FLOAT_MAT3X2,
685		glu::TYPE_FLOAT_MAT3,
686		glu::TYPE_FLOAT_MAT3X4,
687		glu::TYPE_FLOAT_MAT4X2,
688		glu::TYPE_FLOAT_MAT4X3,
689		glu::TYPE_FLOAT_MAT4,
690
691		glu::TYPE_INT,
692		glu::TYPE_INT_VEC2,
693		glu::TYPE_INT_VEC3,
694		glu::TYPE_INT_VEC4,
695
696		glu::TYPE_UINT,
697		glu::TYPE_UINT_VEC2,
698		glu::TYPE_UINT_VEC3,
699		glu::TYPE_UINT_VEC4
700	};
701
702	const int typeTestNumInstances = 4;
703
704	TestCaseGroup* typesGroup = new TestCaseGroup(m_context, "types", "Tests for instanced attributes of particular data types");
705	addChild(typesGroup);
706
707	for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_testTypes); typeNdx++)
708	{
709		glu::DataType type = s_testTypes[typeNdx];
710
711		typesGroup->addChild(new InstancedRenderingCase(m_context, glu::getDataTypeName(type), "",
712														InstancedRenderingCase::FUNCTION_DRAW_ARRAYS_INSTANCED,
713														InstancedRenderingCase::TYPE_ATTRIB_DIVISOR,
714														type,
715														typeTestNumInstances));
716	}
717}
718
719} // Functional
720} // gles3
721} // deqp
722