• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
39 using std::vector;
40 using std::string;
41 
42 namespace deqp
43 {
44 namespace gles3
45 {
46 namespace Functional
47 {
48 
49 static const int	MAX_RENDER_WIDTH		= 128;
50 static const int	MAX_RENDER_HEIGHT		= 128;
51 
52 static const int	QUAD_GRID_SIZE			= 127;
53 
54 // Attribute divisors for the attributes defining the color's RGB components.
55 static const int	ATTRIB_DIVISOR_R		= 3;
56 static const int	ATTRIB_DIVISOR_G		= 2;
57 static const int	ATTRIB_DIVISOR_B		= 1;
58 
59 static 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.
62 static const float	FLOAT_INT_SCALE			= 100.0f;
63 static const float	FLOAT_INT_BIAS			= -50.0f;
64 static const float	FLOAT_UINT_SCALE		= 100.0f;
65 static const float	FLOAT_UINT_BIAS			= 0.0f;
66 
67 // \note Non-anonymous namespace needed; VarComp is used as a template parameter.
68 namespace vcns
69 {
70 
71 union VarComp
72 {
73 	float		f32;
74 	deUint32	u32;
75 	deInt32		i32;
76 
VarComp(float v)77 	VarComp(float v)	: f32(v) {}
VarComp(deUint32 v)78 	VarComp(deUint32 v)	: u32(v) {}
VarComp(deInt32 v)79 	VarComp(deInt32 v)	: i32(v) {}
80 };
81 DE_STATIC_ASSERT(sizeof(VarComp) == sizeof(deUint32));
82 
83 } // vcns
84 
85 using namespace vcns;
86 
87 class InstancedRenderingCase : public TestCase
88 {
89 public:
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 
114 private:
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 
InstancedRenderingCase(Context & context,const char * name,const char * description,DrawFunction function,InstancingType instancingType,glu::DataType rgbAttrType,int numInstances)142 InstancedRenderingCase::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 
~InstancedRenderingCase(void)152 InstancedRenderingCase::~InstancedRenderingCase (void)
153 {
154 	InstancedRenderingCase::deinit();
155 }
156 
157 // Helper function that does biasing and scaling when converting float to integer.
pushVarCompAttrib(vector<VarComp> & vec,float val)158 void 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 
init(void)175 void 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 
deinit(void)428 void InstancedRenderingCase::deinit (void)
429 {
430 	delete m_program;
431 	m_program = DE_NULL;
432 }
433 
iterate(void)434 InstancedRenderingCase::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 
setupVarAttribPointer(const void * attrPtr,int location,int divisor)471 void 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 
setupAndRender(void)505 void 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 
computeReference(tcu::Surface & dst)554 void 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 
InstancedRenderingTests(Context & context)611 InstancedRenderingTests::InstancedRenderingTests (Context& context)
612 	: TestCaseGroup(context, "instanced", "Instanced rendering tests")
613 {
614 }
615 
~InstancedRenderingTests(void)616 InstancedRenderingTests::~InstancedRenderingTests (void)
617 {
618 }
619 
init(void)620 void 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