1#ifndef _GLUSHADERLIBRARY_HPP
2#define _GLUSHADERLIBRARY_HPP
3/*-------------------------------------------------------------------------
4 * drawElements Quality Program OpenGL ES Utilities
5 * ------------------------------------------------
6 *
7 * Copyright 2015 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Shader .test file utilities.
24 *//*--------------------------------------------------------------------*/
25
26#include "gluDefs.hpp"
27#include "gluVarType.hpp"
28#include "gluShaderProgram.hpp"
29#include "tcuTestCase.hpp"
30
31#include <string>
32#include <vector>
33
34namespace glu
35{
36namespace sl
37{
38
39enum CaseType
40{
41	CASETYPE_COMPLETE = 0,		//!< Has all shaders specified separately.
42	CASETYPE_VERTEX_ONLY,		//!< "Both" case, vertex shader sub case.
43	CASETYPE_FRAGMENT_ONLY,		//!< "Both" case, fragment shader sub case.
44
45	CASETYPE_LAST
46};
47
48enum ExpectResult
49{
50	EXPECT_PASS = 0,
51	EXPECT_COMPILE_FAIL,
52	EXPECT_LINK_FAIL,
53	EXPECT_COMPILE_LINK_FAIL,
54	EXPECT_VALIDATION_FAIL,
55	EXPECT_BUILD_SUCCESSFUL,
56
57	EXPECT_LAST
58};
59
60enum OutputType
61{
62	OUTPUT_RESULT = 0,
63	OUTPUT_COLOR,
64
65	OUTPUT_LAST
66};
67
68struct Value
69{
70	union Element
71	{
72		float		float32;
73		deInt32		int32;
74		deInt32		bool32;
75	};
76
77	VarType					type;
78	std::string				name;
79	std::vector<Element>	elements;		// Scalar values (variable.varType.getScalarSize() * #values).
80};
81
82struct ValueBlock
83{
84	std::vector<Value>		inputs;
85	std::vector<Value>		outputs;
86	std::vector<Value>		uniforms;
87};
88
89enum CapabilityType
90{
91	CAPABILITY_LIMIT = 0,
92	CAPABILITY_FLAG,
93
94	CAPABILITY_LAST
95};
96
97enum CapabilityFlag
98{
99	CAPABILITY_FULL_GLSL_ES_100_SUPPORT,
100	CAPABILITY_ONLY_GLSL_ES_100_SUPPORT, // only ES2, no ES3 capability
101	CAPABILITY_EXACTLY_ONE_DRAW_BUFFER	 // gl_MaxDrawBuffers is exactly 1
102};
103
104struct RequiredCapability
105{
106	CapabilityType			type;
107
108	union
109	{
110		CapabilityFlag		flagName;
111		deUint32			enumName;
112	};
113
114	int						referenceValue;
115
116	RequiredCapability (CapabilityFlag flagName_)
117		: type				(CAPABILITY_FLAG)
118		, flagName			(flagName_)
119		, referenceValue	(0) // not used
120	{
121	}
122
123	RequiredCapability (deUint32 enumName_, int referenceValue_)
124		: type				(CAPABILITY_LIMIT)
125		, enumName			(enumName_)
126		, referenceValue	(referenceValue_)
127	{
128	}
129};
130
131struct RequiredExtension
132{
133	std::vector<std::string>	alternatives;		// One or more extensions, at least one (but not all) must be supported
134	deUint32					effectiveStages;	// Bitfield of shader stages requiring this extension
135
136	RequiredExtension (const std::vector<std::string>&	alternatives_,
137					   deUint32							effectiveStages_)
138		: alternatives		(alternatives_)
139		, effectiveStages	(effectiveStages_)
140	{
141	}
142
143		RequiredExtension (const std::string&	extension,
144						   deUint32				effectiveStages_)
145		: effectiveStages	(effectiveStages_)
146	{
147		alternatives.push_back(extension);
148	}
149
150	RequiredExtension (void)
151		: effectiveStages	(0u)
152	{
153	}
154};
155
156struct ProgramSpecification
157{
158	glu::ProgramSources				sources;
159	std::vector<RequiredExtension>	requiredExtensions;
160	deUint32						activeStages;	// Has an effect only if sources.separable == true, must be 0 otherwise
161
162	ProgramSpecification (void)
163		: activeStages(0u)
164	{
165	}
166};
167
168struct ShaderCaseSpecification
169{
170	CaseType							caseType;
171	ExpectResult						expectResult;
172	OutputType							outputType;
173	DataType							outputFormat;
174	glu::GLSLVersion					targetVersion;
175
176	std::vector<RequiredCapability>		requiredCaps;
177
178	ValueBlock							values;
179	std::vector<ProgramSpecification>	programs;
180
181	ShaderCaseSpecification (void)
182		: caseType				(CASETYPE_LAST)
183		, expectResult			(EXPECT_LAST)
184		, outputType			(OUTPUT_RESULT)
185		, outputFormat			(TYPE_LAST)
186		, targetVersion			(glu::GLSL_VERSION_LAST)
187	{
188	}
189};
190
191bool	isValid		(const ValueBlock& block);
192bool	isValid		(const ShaderCaseSpecification& spec);
193
194bool	isCapabilityRequired(CapabilityFlag capabilityFlag, const ShaderCaseSpecification& spec);
195
196class ShaderCaseFactory
197{
198public:
199	virtual tcu::TestCaseGroup*	createGroup	(const std::string& name, const std::string& description, const std::vector<tcu::TestNode*>& children) = 0;
200	virtual tcu::TestCase*		createCase	(const std::string& name, const std::string& description, const ShaderCaseSpecification& spec) = 0;
201};
202
203std::vector<tcu::TestNode*>		parseFile	(const tcu::Archive& archive, const std::string& filename, ShaderCaseFactory* caseFactory);
204
205// Specialization utilties
206
207struct ProgramSpecializationParams
208{
209	const ShaderCaseSpecification&			caseSpec;
210	const std::vector<RequiredExtension>	requiredExtensions;	// Extensions, must be resolved to single ext per entry
211	const int								maxPatchVertices;	// Used by tess shaders only
212
213	ProgramSpecializationParams (const ShaderCaseSpecification&			caseSpec_,
214								 const std::vector<RequiredExtension>&	requiredExtensions_,
215								 int									maxPatchVertices_)
216		: caseSpec				(caseSpec_)
217		, requiredExtensions	(requiredExtensions_)
218		, maxPatchVertices		(maxPatchVertices_)
219	{
220	}
221};
222
223void			genCompareFunctions			(std::ostringstream& stream, const ValueBlock& valueBlock, bool useFloatTypes);
224std::string		injectExtensionRequirements	(const std::string& baseCode, const std::vector<RequiredExtension>& extensions, ShaderType shaderType);
225
226// Other utilities
227
228void			dumpValues					(tcu::TestLog& log, const ValueBlock& values, int arrayNdx);
229
230} // sl
231} // glu
232
233#endif // _GLUSHADERLIBRARY_HPP
234