1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL (ES) 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 Random uniform block layout case.
22 *//*--------------------------------------------------------------------*/
23
24#include "glsRandomUniformBlockCase.hpp"
25#include "tcuCommandLine.hpp"
26#include "deRandom.hpp"
27#include "deStringUtil.hpp"
28
29using std::string;
30using std::vector;
31
32namespace deqp
33{
34namespace gls
35{
36
37using namespace gls::ub;
38
39RandomUniformBlockCase::RandomUniformBlockCase (tcu::TestContext&	testCtx,
40												glu::RenderContext&	renderCtx,
41												glu::GLSLVersion	glslVersion,
42												const char*			name,
43												const char*			description,
44												BufferMode			bufferMode,
45												deUint32			features,
46												deUint32			seed)
47	: UniformBlockCase		(testCtx, renderCtx, name, description, glslVersion, bufferMode)
48	, m_features			(features)
49	, m_maxVertexBlocks		((features & FEATURE_VERTEX_BLOCKS)		? 4 : 0)
50	, m_maxFragmentBlocks	((features & FEATURE_FRAGMENT_BLOCKS)	? 4 : 0)
51	, m_maxSharedBlocks		((features & FEATURE_SHARED_BLOCKS)		? 4 : 0)
52	, m_maxInstances		((features & FEATURE_INSTANCE_ARRAYS)	? 3 : 0)
53	, m_maxArrayLength		((features & FEATURE_ARRAYS)			? 8 : 0)
54	, m_maxStructDepth		((features & FEATURE_STRUCTS)			? 2 : 0)
55	, m_maxBlockMembers		(5)
56	, m_maxStructMembers	(4)
57	, m_seed				(seed)
58	, m_blockNdx			(1)
59	, m_uniformNdx			(1)
60	, m_structNdx			(1)
61{
62}
63
64void RandomUniformBlockCase::init (void)
65{
66	de::Random rnd(m_seed);
67
68	int numShared		= m_maxSharedBlocks				> 0	? rnd.getInt(1, m_maxSharedBlocks)				: 0;
69	int numVtxBlocks	= m_maxVertexBlocks-numShared	> 0	? rnd.getInt(1, m_maxVertexBlocks-numShared)	: 0;
70	int	numFragBlocks	= m_maxFragmentBlocks-numShared	> 0 ? rnd.getInt(1, m_maxFragmentBlocks-numShared)	: 0;
71
72	for (int ndx = 0; ndx < numShared; ndx++)
73		generateBlock(rnd, DECLARE_VERTEX|DECLARE_FRAGMENT);
74
75	for (int ndx = 0; ndx < numVtxBlocks; ndx++)
76		generateBlock(rnd, DECLARE_VERTEX);
77
78	for (int ndx = 0; ndx < numFragBlocks; ndx++)
79		generateBlock(rnd, DECLARE_FRAGMENT);
80}
81
82void RandomUniformBlockCase::generateBlock (de::Random& rnd, deUint32 layoutFlags)
83{
84	DE_ASSERT(m_blockNdx <= 'z' - 'a');
85
86	const float		instanceArrayWeight	= 0.3f;
87	UniformBlock&	block				= m_interface.allocBlock((string("Block") + (char)('A' + m_blockNdx)).c_str());
88	int				numInstances		= (m_maxInstances > 0 && rnd.getFloat() < instanceArrayWeight) ? rnd.getInt(0, m_maxInstances) : 0;
89	int				numUniforms			= rnd.getInt(1, m_maxBlockMembers);
90
91	if (numInstances > 0)
92		block.setArraySize(numInstances);
93
94	if (numInstances > 0 || rnd.getBool())
95		block.setInstanceName((string("block") + (char)('A' + m_blockNdx)).c_str());
96
97	// Layout flag candidates.
98	vector<deUint32> layoutFlagCandidates;
99	layoutFlagCandidates.push_back(0);
100	if (m_features & FEATURE_PACKED_LAYOUT)
101		layoutFlagCandidates.push_back(LAYOUT_SHARED);
102	if ((m_features & FEATURE_SHARED_LAYOUT) && ((layoutFlags & DECLARE_BOTH) != DECLARE_BOTH))
103		layoutFlagCandidates.push_back(LAYOUT_PACKED); // \note packed layout can only be used in a single shader stage.
104	if (m_features & FEATURE_STD140_LAYOUT)
105		layoutFlagCandidates.push_back(LAYOUT_STD140);
106
107	layoutFlags |= rnd.choose<deUint32>(layoutFlagCandidates.begin(), layoutFlagCandidates.end());
108
109	if (m_features & FEATURE_MATRIX_LAYOUT)
110	{
111		static const deUint32 matrixCandidates[] = { 0, LAYOUT_ROW_MAJOR, LAYOUT_COLUMN_MAJOR };
112		layoutFlags |= rnd.choose<deUint32>(&matrixCandidates[0], &matrixCandidates[DE_LENGTH_OF_ARRAY(matrixCandidates)]);
113	}
114
115	block.setFlags(layoutFlags);
116
117	for (int ndx = 0; ndx < numUniforms; ndx++)
118		generateUniform(rnd, block);
119
120	m_blockNdx += 1;
121}
122
123static std::string genName (char first, char last, int ndx)
124{
125	std::string	str			= "";
126	int			alphabetLen	= last - first + 1;
127
128	while (ndx > alphabetLen)
129	{
130		str.insert(str.begin(), (char)(first + ((ndx-1)%alphabetLen)));
131		ndx = ((ndx-1) / alphabetLen);
132	}
133
134	str.insert(str.begin(), (char)(first + (ndx%(alphabetLen+1)) - 1));
135
136	return str;
137}
138
139void RandomUniformBlockCase::generateUniform (de::Random& rnd, UniformBlock& block)
140{
141	const float		unusedVtxWeight		= 0.15f;
142	const float		unusedFragWeight	= 0.15f;
143	bool			unusedOk			= (m_features & FEATURE_UNUSED_UNIFORMS) != 0;
144	deUint32		flags				= 0;
145	std::string		name				= genName('a', 'z', m_uniformNdx);
146	VarType			type				= generateType(rnd, 0, true);
147
148	flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight)		? UNUSED_VERTEX		: 0;
149	flags |= (unusedOk && rnd.getFloat() < unusedFragWeight)	? UNUSED_FRAGMENT	: 0;
150
151	block.addUniform(Uniform(name.c_str(), type, flags));
152
153	m_uniformNdx += 1;
154}
155
156VarType RandomUniformBlockCase::generateType (de::Random& rnd, int typeDepth, bool arrayOk)
157{
158	const float structWeight	= 0.1f;
159	const float arrayWeight		= 0.1f;
160
161	if (typeDepth < m_maxStructDepth && rnd.getFloat() < structWeight)
162	{
163		const float		unusedVtxWeight		= 0.15f;
164		const float		unusedFragWeight	= 0.15f;
165		bool			unusedOk			= (m_features & FEATURE_UNUSED_MEMBERS) != 0;
166		vector<VarType>	memberTypes;
167		int				numMembers = rnd.getInt(1, m_maxStructMembers);
168
169		// Generate members first so nested struct declarations are in correct order.
170		for (int ndx = 0; ndx < numMembers; ndx++)
171			memberTypes.push_back(generateType(rnd, typeDepth+1, true));
172
173		StructType& structType = m_interface.allocStruct((string("s") + genName('A', 'Z', m_structNdx)).c_str());
174		m_structNdx += 1;
175
176		DE_ASSERT(numMembers <= 'Z' - 'A');
177		for (int ndx = 0; ndx < numMembers; ndx++)
178		{
179			deUint32 flags = 0;
180
181			flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight)		? UNUSED_VERTEX		: 0;
182			flags |= (unusedOk && rnd.getFloat() < unusedFragWeight)	? UNUSED_FRAGMENT	: 0;
183
184			structType.addMember((string("m") + (char)('A' + ndx)).c_str(), memberTypes[ndx], flags);
185		}
186
187		return VarType(&structType);
188	}
189	else if (m_maxArrayLength > 0 && arrayOk && rnd.getFloat() < arrayWeight)
190	{
191		const bool	arraysOfArraysOk	= (m_features & FEATURE_ARRAYS_OF_ARRAYS) != 0;
192		const int	arrayLength			= rnd.getInt(1, m_maxArrayLength);
193		VarType	elementType	= generateType(rnd, typeDepth, arraysOfArraysOk);
194		return VarType(elementType, arrayLength);
195	}
196	else
197	{
198		vector<glu::DataType> typeCandidates;
199
200		typeCandidates.push_back(glu::TYPE_FLOAT);
201		typeCandidates.push_back(glu::TYPE_INT);
202		typeCandidates.push_back(glu::TYPE_UINT);
203		typeCandidates.push_back(glu::TYPE_BOOL);
204
205		if (m_features & FEATURE_VECTORS)
206		{
207			typeCandidates.push_back(glu::TYPE_FLOAT_VEC2);
208			typeCandidates.push_back(glu::TYPE_FLOAT_VEC3);
209			typeCandidates.push_back(glu::TYPE_FLOAT_VEC4);
210			typeCandidates.push_back(glu::TYPE_INT_VEC2);
211			typeCandidates.push_back(glu::TYPE_INT_VEC3);
212			typeCandidates.push_back(glu::TYPE_INT_VEC4);
213			typeCandidates.push_back(glu::TYPE_UINT_VEC2);
214			typeCandidates.push_back(glu::TYPE_UINT_VEC3);
215			typeCandidates.push_back(glu::TYPE_UINT_VEC4);
216			typeCandidates.push_back(glu::TYPE_BOOL_VEC2);
217			typeCandidates.push_back(glu::TYPE_BOOL_VEC3);
218			typeCandidates.push_back(glu::TYPE_BOOL_VEC4);
219		}
220
221		if (m_features & FEATURE_MATRICES)
222		{
223			typeCandidates.push_back(glu::TYPE_FLOAT_MAT2);
224			typeCandidates.push_back(glu::TYPE_FLOAT_MAT2X3);
225			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3X2);
226			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3);
227			typeCandidates.push_back(glu::TYPE_FLOAT_MAT3X4);
228			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4X2);
229			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4X3);
230			typeCandidates.push_back(glu::TYPE_FLOAT_MAT4);
231		}
232
233		glu::DataType	type	= rnd.choose<glu::DataType>(typeCandidates.begin(), typeCandidates.end());
234		deUint32		flags	= 0;
235
236		if (!glu::isDataTypeBoolOrBVec(type))
237		{
238			// Precision.
239			static const deUint32 precisionCandidates[] = { PRECISION_LOW, PRECISION_MEDIUM, PRECISION_HIGH };
240			flags |= rnd.choose<deUint32>(&precisionCandidates[0], &precisionCandidates[DE_LENGTH_OF_ARRAY(precisionCandidates)]);
241		}
242
243		return VarType(type, flags);
244	}
245}
246
247} // gls
248} // deqp
249