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 Shader discard statement tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fShaderDiscardTests.hpp"
25 #include "glsShaderRenderCase.hpp"
26 #include "tcuStringTemplate.hpp"
27 #include "gluTexture.hpp"
28
29 #include <map>
30 #include <sstream>
31 #include <string>
32
33 #include "glwEnums.hpp"
34 #include "glwFunctions.hpp"
35
36 using tcu::StringTemplate;
37
38 using std::map;
39 using std::ostringstream;
40 using std::string;
41
42 using namespace glu;
43 using namespace deqp::gls;
44
45 namespace deqp
46 {
47 namespace gles3
48 {
49 namespace Functional
50 {
51
52 class ShaderDiscardCase : public ShaderRenderCase
53 {
54 public:
55 ShaderDiscardCase(Context &context, const char *name, const char *description, const char *shaderSource,
56 ShaderEvalFunc evalFunc, bool usesTexture);
57 virtual ~ShaderDiscardCase(void);
58
59 void init(void);
60 void deinit(void);
61
62 void setupUniforms(int programID, const tcu::Vec4 &constCoords);
63
64 private:
65 bool m_usesTexture;
66 glu::Texture2D *m_brickTexture;
67 };
68
ShaderDiscardCase(Context & context,const char * name,const char * description,const char * shaderSource,ShaderEvalFunc evalFunc,bool usesTexture)69 ShaderDiscardCase::ShaderDiscardCase(Context &context, const char *name, const char *description,
70 const char *shaderSource, ShaderEvalFunc evalFunc, bool usesTexture)
71 : ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name,
72 description, false, evalFunc)
73 , m_usesTexture(usesTexture)
74 , m_brickTexture(DE_NULL)
75 {
76 m_fragShaderSource = shaderSource;
77 m_vertShaderSource = "#version 300 es\n"
78 "in highp vec4 a_position;\n"
79 "in highp vec4 a_coords;\n"
80 "out mediump vec4 v_color;\n"
81 "out mediump vec4 v_coords;\n\n"
82 "void main (void)\n"
83 "{\n"
84 " gl_Position = a_position;\n"
85 " v_color = vec4(a_coords.xyz, 1.0);\n"
86 " v_coords = a_coords;\n"
87 "}\n";
88 }
89
~ShaderDiscardCase(void)90 ShaderDiscardCase::~ShaderDiscardCase(void)
91 {
92 delete m_brickTexture;
93 }
94
init(void)95 void ShaderDiscardCase::init(void)
96 {
97 if (m_usesTexture)
98 {
99 m_brickTexture = glu::Texture2D::create(m_renderCtx, m_ctxInfo, m_testCtx.getArchive(), "data/brick.png");
100 m_textures.push_back(TextureBinding(
101 m_brickTexture, tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
102 tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::LINEAR, tcu::Sampler::LINEAR)));
103 }
104 gls::ShaderRenderCase::init();
105 }
106
deinit(void)107 void ShaderDiscardCase::deinit(void)
108 {
109 gls::ShaderRenderCase::deinit();
110 delete m_brickTexture;
111 m_brickTexture = DE_NULL;
112 }
113
setupUniforms(int programID,const tcu::Vec4 &)114 void ShaderDiscardCase::setupUniforms(int programID, const tcu::Vec4 &)
115 {
116 const glw::Functions &gl = m_renderCtx.getFunctions();
117 gl.uniform1i(gl.getUniformLocation(programID, "ut_brick"), 0);
118 }
119
ShaderDiscardTests(Context & context)120 ShaderDiscardTests::ShaderDiscardTests(Context &context) : TestCaseGroup(context, "discard", "Discard statement tests")
121 {
122 }
123
~ShaderDiscardTests(void)124 ShaderDiscardTests::~ShaderDiscardTests(void)
125 {
126 }
127
128 enum DiscardMode
129 {
130 DISCARDMODE_ALWAYS = 0,
131 DISCARDMODE_NEVER,
132 DISCARDMODE_UNIFORM,
133 DISCARDMODE_DYNAMIC,
134 DISCARDMODE_TEXTURE,
135
136 DISCARDMODE_LAST
137 };
138
139 enum DiscardTemplate
140 {
141 DISCARDTEMPLATE_MAIN_BASIC = 0,
142 DISCARDTEMPLATE_FUNCTION_BASIC,
143 DISCARDTEMPLATE_MAIN_STATIC_LOOP,
144 DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP,
145 DISCARDTEMPLATE_FUNCTION_STATIC_LOOP,
146
147 DISCARDTEMPLATE_LAST
148 };
149
150 // Evaluation functions
evalDiscardAlways(ShaderEvalContext & c)151 inline void evalDiscardAlways(ShaderEvalContext &c)
152 {
153 c.discard();
154 }
evalDiscardNever(ShaderEvalContext & c)155 inline void evalDiscardNever(ShaderEvalContext &c)
156 {
157 c.color.xyz() = c.coords.swizzle(0, 1, 2);
158 }
evalDiscardDynamic(ShaderEvalContext & c)159 inline void evalDiscardDynamic(ShaderEvalContext &c)
160 {
161 c.color.xyz() = c.coords.swizzle(0, 1, 2);
162 if (c.coords.x() + c.coords.y() > 0.0f)
163 c.discard();
164 }
165
evalDiscardTexture(ShaderEvalContext & c)166 inline void evalDiscardTexture(ShaderEvalContext &c)
167 {
168 c.color.xyz() = c.coords.swizzle(0, 1, 2);
169 if (c.texture2D(0, c.coords.swizzle(0, 1) * 0.25f + 0.5f).x() < 0.7f)
170 c.discard();
171 }
172
getEvalFunc(DiscardMode mode)173 static ShaderEvalFunc getEvalFunc(DiscardMode mode)
174 {
175 switch (mode)
176 {
177 case DISCARDMODE_ALWAYS:
178 return evalDiscardAlways;
179 case DISCARDMODE_NEVER:
180 return evalDiscardNever;
181 case DISCARDMODE_UNIFORM:
182 return evalDiscardAlways;
183 case DISCARDMODE_DYNAMIC:
184 return evalDiscardDynamic;
185 case DISCARDMODE_TEXTURE:
186 return evalDiscardTexture;
187 default:
188 DE_ASSERT(false);
189 return evalDiscardAlways;
190 }
191 }
192
getTemplate(DiscardTemplate variant)193 static const char *getTemplate(DiscardTemplate variant)
194 {
195 switch (variant)
196 {
197 case DISCARDTEMPLATE_MAIN_BASIC:
198 return "#version 300 es\n"
199 "in mediump vec4 v_color;\n"
200 "in mediump vec4 v_coords;\n"
201 "layout(location = 0) out mediump vec4 o_color;\n"
202 "uniform sampler2D ut_brick;\n"
203 "uniform mediump int ui_one;\n\n"
204 "void main (void)\n"
205 "{\n"
206 " o_color = v_color;\n"
207 " ${DISCARD};\n"
208 "}\n";
209
210 case DISCARDTEMPLATE_FUNCTION_BASIC:
211 return "#version 300 es\n"
212 "in mediump vec4 v_color;\n"
213 "in mediump vec4 v_coords;\n"
214 "layout(location = 0) out mediump vec4 o_color;\n"
215 "uniform sampler2D ut_brick;\n"
216 "uniform mediump int ui_one;\n\n"
217 "void myfunc (void)\n"
218 "{\n"
219 " ${DISCARD};\n"
220 "}\n\n"
221 "void main (void)\n"
222 "{\n"
223 " o_color = v_color;\n"
224 " myfunc();\n"
225 "}\n";
226
227 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
228 return "#version 300 es\n"
229 "in mediump vec4 v_color;\n"
230 "in mediump vec4 v_coords;\n"
231 "layout(location = 0) out mediump vec4 o_color;\n"
232 "uniform sampler2D ut_brick;\n"
233 "uniform mediump int ui_one;\n\n"
234 "void main (void)\n"
235 "{\n"
236 " o_color = v_color;\n"
237 " for (int i = 0; i < 2; i++)\n"
238 " {\n"
239 " if (i > 0)\n"
240 " ${DISCARD};\n"
241 " }\n"
242 "}\n";
243
244 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
245 return "#version 300 es\n"
246 "in mediump vec4 v_color;\n"
247 "in mediump vec4 v_coords;\n"
248 "layout(location = 0) out mediump vec4 o_color;\n"
249 "uniform sampler2D ut_brick;\n"
250 "uniform mediump int ui_one;\n"
251 "uniform mediump int ui_two;\n\n"
252 "void main (void)\n"
253 "{\n"
254 " o_color = v_color;\n"
255 " for (int i = 0; i < ui_two; i++)\n"
256 " {\n"
257 " if (i > 0)\n"
258 " ${DISCARD};\n"
259 " }\n"
260 "}\n";
261
262 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
263 return "#version 300 es\n"
264 "in mediump vec4 v_color;\n"
265 "in mediump vec4 v_coords;\n"
266 "layout(location = 0) out mediump vec4 o_color;\n"
267 "uniform sampler2D ut_brick;\n"
268 "uniform mediump int ui_one;\n\n"
269 "void myfunc (void)\n"
270 "{\n"
271 " for (int i = 0; i < 2; i++)\n"
272 " {\n"
273 " if (i > 0)\n"
274 " ${DISCARD};\n"
275 " }\n"
276 "}\n\n"
277 "void main (void)\n"
278 "{\n"
279 " o_color = v_color;\n"
280 " myfunc();\n"
281 "}\n";
282
283 default:
284 DE_ASSERT(false);
285 return DE_NULL;
286 }
287 }
288
getTemplateName(DiscardTemplate variant)289 static const char *getTemplateName(DiscardTemplate variant)
290 {
291 switch (variant)
292 {
293 case DISCARDTEMPLATE_MAIN_BASIC:
294 return "basic";
295 case DISCARDTEMPLATE_FUNCTION_BASIC:
296 return "function";
297 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
298 return "static_loop";
299 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
300 return "dynamic_loop";
301 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
302 return "function_static_loop";
303 default:
304 DE_ASSERT(false);
305 return DE_NULL;
306 }
307 }
308
getModeName(DiscardMode mode)309 static const char *getModeName(DiscardMode mode)
310 {
311 switch (mode)
312 {
313 case DISCARDMODE_ALWAYS:
314 return "always";
315 case DISCARDMODE_NEVER:
316 return "never";
317 case DISCARDMODE_UNIFORM:
318 return "uniform";
319 case DISCARDMODE_DYNAMIC:
320 return "dynamic";
321 case DISCARDMODE_TEXTURE:
322 return "texture";
323 default:
324 DE_ASSERT(false);
325 return DE_NULL;
326 }
327 }
328
getTemplateDesc(DiscardTemplate variant)329 static const char *getTemplateDesc(DiscardTemplate variant)
330 {
331 switch (variant)
332 {
333 case DISCARDTEMPLATE_MAIN_BASIC:
334 return "main";
335 case DISCARDTEMPLATE_FUNCTION_BASIC:
336 return "function";
337 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
338 return "static loop";
339 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
340 return "dynamic loop";
341 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
342 return "static loop in function";
343 default:
344 DE_ASSERT(false);
345 return DE_NULL;
346 }
347 }
348
getModeDesc(DiscardMode mode)349 static const char *getModeDesc(DiscardMode mode)
350 {
351 switch (mode)
352 {
353 case DISCARDMODE_ALWAYS:
354 return "Always discard";
355 case DISCARDMODE_NEVER:
356 return "Never discard";
357 case DISCARDMODE_UNIFORM:
358 return "Discard based on uniform value";
359 case DISCARDMODE_DYNAMIC:
360 return "Discard based on varying values";
361 case DISCARDMODE_TEXTURE:
362 return "Discard based on texture value";
363 default:
364 DE_ASSERT(false);
365 return DE_NULL;
366 }
367 }
368
makeDiscardCase(Context & context,DiscardTemplate tmpl,DiscardMode mode)369 ShaderDiscardCase *makeDiscardCase(Context &context, DiscardTemplate tmpl, DiscardMode mode)
370 {
371 StringTemplate shaderTemplate(getTemplate(tmpl));
372
373 map<string, string> params;
374
375 switch (mode)
376 {
377 case DISCARDMODE_ALWAYS:
378 params["DISCARD"] = "discard";
379 break;
380 case DISCARDMODE_NEVER:
381 params["DISCARD"] = "if (false) discard";
382 break;
383 case DISCARDMODE_UNIFORM:
384 params["DISCARD"] = "if (ui_one > 0) discard";
385 break;
386 case DISCARDMODE_DYNAMIC:
387 params["DISCARD"] = "if (v_coords.x+v_coords.y > 0.0) discard";
388 break;
389 case DISCARDMODE_TEXTURE:
390 params["DISCARD"] = "if (texture(ut_brick, v_coords.xy*0.25+0.5).x < 0.7) discard";
391 break;
392 default:
393 DE_ASSERT(false);
394 break;
395 }
396
397 string name = string(getTemplateName(tmpl)) + "_" + getModeName(mode);
398 string description = string(getModeDesc(mode)) + " in " + getTemplateDesc(tmpl);
399
400 return new ShaderDiscardCase(context, name.c_str(), description.c_str(), shaderTemplate.specialize(params).c_str(),
401 getEvalFunc(mode), mode == DISCARDMODE_TEXTURE);
402 }
403
init(void)404 void ShaderDiscardTests::init(void)
405 {
406 for (int tmpl = 0; tmpl < DISCARDTEMPLATE_LAST; tmpl++)
407 for (int mode = 0; mode < DISCARDMODE_LAST; mode++)
408 addChild(makeDiscardCase(m_context, (DiscardTemplate)tmpl, (DiscardMode)mode));
409 }
410
411 } // namespace Functional
412 } // namespace gles3
413 } // namespace deqp
414
