modules/gles3/functional/es3fShaderDiscardTests.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program OpenGL ES 3.0 Module
  * -------------------------------------------------
  *
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Shader discard statement tests.
  *//*--------------------------------------------------------------------*/

 #include "es3fShaderDiscardTests.hpp"
 #include "glsShaderRenderCase.hpp"
 #include "tcuStringTemplate.hpp"
 #include "gluTexture.hpp"

 #include <map>
 #include <sstream>
 #include <string>

 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"

 using tcu::StringTemplate;

 using std::map;
 using std::string;
 using std::ostringstream;

 using namespace glu;
 using namespace deqp::gls;

 namespace deqp
 {
 namespace gles3
 {
 namespace Functional
 {

 class ShaderDiscardCase : public ShaderRenderCase
 {
 public:
 						ShaderDiscardCase			(Context& context, const char* name, const char* description, const char* shaderSource, ShaderEvalFunc evalFunc, bool usesTexture);
 	virtual				~ShaderDiscardCase			(void);

 	void				init						(void);
 	void				deinit						(void);

 	void				setupUniforms				(int programID, const tcu::Vec4& constCoords);

 private:
 	bool				m_usesTexture;
 	glu::Texture2D*		m_brickTexture;
 };

 ShaderDiscardCase::ShaderDiscardCase (Context& context, const char* name, const char* description, const char* shaderSource, ShaderEvalFunc evalFunc, bool usesTexture)
 	: ShaderRenderCase	(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, description, false, evalFunc)
 	, m_usesTexture		(usesTexture)
 	, m_brickTexture	(DE_NULL)
 {
 	m_fragShaderSource	= shaderSource;
 	m_vertShaderSource	=
 		"#version 300 es\n"
 		"in  highp   vec4 a_position;\n"
 		"in  highp   vec4 a_coords;\n"
 		"out mediump vec4 v_color;\n"
 		"out mediump vec4 v_coords;\n\n"
 		"void main (void)\n"
 		"{\n"
 		"    gl_Position = a_position;\n"
 		"    v_color = vec4(a_coords.xyz, 1.0);\n"
 		"    v_coords = a_coords;\n"
 		"}\n";
 }

 ShaderDiscardCase::~ShaderDiscardCase (void)
 {
 	delete m_brickTexture;
 }

 void ShaderDiscardCase::init (void)
 {
 	if (m_usesTexture)
 	{
 		m_brickTexture = glu::Texture2D::create(m_renderCtx, m_ctxInfo, m_testCtx.getArchive(), "data/brick.png");
 		m_textures.push_back(TextureBinding(m_brickTexture, tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
 																		 tcu::Sampler::LINEAR, tcu::Sampler::LINEAR)));
 	}
 	gls::ShaderRenderCase::init();
 }

 void ShaderDiscardCase::deinit (void)
 {
 	gls::ShaderRenderCase::deinit();
 	delete m_brickTexture;
 	m_brickTexture = DE_NULL;
 }

 void ShaderDiscardCase::setupUniforms (int programID, const tcu::Vec4&)
 {
 	const glw::Functions& gl = m_renderCtx.getFunctions();
 	gl.uniform1i(gl.getUniformLocation(programID, "ut_brick"), 0);
 }

 ShaderDiscardTests::ShaderDiscardTests (Context& context)
 	: TestCaseGroup(context, "discard", "Discard statement tests")
 {
 }

 ShaderDiscardTests::~ShaderDiscardTests (void)
 {
 }

 enum DiscardMode
 {
 	DISCARDMODE_ALWAYS = 0,
 	DISCARDMODE_NEVER,
 	DISCARDMODE_UNIFORM,
 	DISCARDMODE_DYNAMIC,
 	DISCARDMODE_TEXTURE,

 	DISCARDMODE_LAST
 };

 enum DiscardTemplate
 {
 	DISCARDTEMPLATE_MAIN_BASIC = 0,
 	DISCARDTEMPLATE_FUNCTION_BASIC,
 	DISCARDTEMPLATE_MAIN_STATIC_LOOP,
 	DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP,
 	DISCARDTEMPLATE_FUNCTION_STATIC_LOOP,

 	DISCARDTEMPLATE_LAST
 };

 // Evaluation functions
 inline void evalDiscardAlways	(ShaderEvalContext& c) { c.discard(); }
 inline void evalDiscardNever	(ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
 inline void evalDiscardDynamic	(ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); if (c.coords.x()+c.coords.y() > 0.0f) c.discard(); }

 inline void evalDiscardTexture (ShaderEvalContext& c)
 {
 	c.color.xyz() = c.coords.swizzle(0,1,2);
 	if (c.texture2D(0, c.coords.swizzle(0,1) * 0.25f + 0.5f).x() < 0.7f)
 		c.discard();
 }

 static ShaderEvalFunc getEvalFunc (DiscardMode mode)
 {
 	switch (mode)
 	{
 		case DISCARDMODE_ALWAYS:	return evalDiscardAlways;
 		case DISCARDMODE_NEVER:		return evalDiscardNever;
 		case DISCARDMODE_UNIFORM:	return evalDiscardAlways;
 		case DISCARDMODE_DYNAMIC:	return evalDiscardDynamic;
 		case DISCARDMODE_TEXTURE:	return evalDiscardTexture;
 		default:
 			DE_ASSERT(DE_FALSE);
 			return evalDiscardAlways;
 	}
 }

 static const char* getTemplate (DiscardTemplate variant)
 {
 	switch (variant)
 	{
 		case DISCARDTEMPLATE_MAIN_BASIC:
 			return "#version 300 es\n"
 				   "in mediump vec4 v_color;\n"
 				   "in mediump vec4 v_coords;\n"
 				   "layout(location = 0) out mediump vec4 o_color;\n"
 				   "uniform sampler2D    ut_brick;\n"
 				   "uniform mediump int  ui_one;\n\n"
 				   "void main (void)\n"
 				   "{\n"
 				   "    o_color = v_color;\n"
 				   "    ${DISCARD};\n"
 				   "}\n";

 		case DISCARDTEMPLATE_FUNCTION_BASIC:
 			return "#version 300 es\n"
 				   "in mediump vec4 v_color;\n"
 				   "in mediump vec4 v_coords;\n"
 				   "layout(location = 0) out mediump vec4 o_color;\n"
 				   "uniform sampler2D    ut_brick;\n"
 				   "uniform mediump int  ui_one;\n\n"
 				   "void myfunc (void)\n"
 				   "{\n"
 				   "    ${DISCARD};\n"
 				   "}\n\n"
 				   "void main (void)\n"
 				   "{\n"
 				   "    o_color = v_color;\n"
 				   "    myfunc();\n"
 				   "}\n";

 		case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
 			return "#version 300 es\n"
 				   "in mediump vec4 v_color;\n"
 				   "in mediump vec4 v_coords;\n"
 				   "layout(location = 0) out mediump vec4 o_color;\n"
 				   "uniform sampler2D    ut_brick;\n"
 				   "uniform mediump int  ui_one;\n\n"
 				   "void main (void)\n"
 				   "{\n"
 				   "    o_color = v_color;\n"
 				   "    for (int i = 0; i < 2; i++)\n"
 				   "    {\n"
 				   "        if (i > 0)\n"
 				   "            ${DISCARD};\n"
 				   "    }\n"
 				   "}\n";

 		case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
 			return "#version 300 es\n"
 				   "in mediump vec4 v_color;\n"
 				   "in mediump vec4 v_coords;\n"
 				   "layout(location = 0) out mediump vec4 o_color;\n"
 				   "uniform sampler2D    ut_brick;\n"
 				   "uniform mediump int  ui_one;\n"
 				   "uniform mediump int  ui_two;\n\n"
 				   "void main (void)\n"
 				   "{\n"
 				   "    o_color = v_color;\n"
 				   "    for (int i = 0; i < ui_two; i++)\n"
 				   "    {\n"
 				   "        if (i > 0)\n"
 				   "            ${DISCARD};\n"
 				   "    }\n"
 				   "}\n";

 		case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
 			return "#version 300 es\n"
 				   "in mediump vec4 v_color;\n"
 				   "in mediump vec4 v_coords;\n"
 				   "layout(location = 0) out mediump vec4 o_color;\n"
 				   "uniform sampler2D    ut_brick;\n"
 				   "uniform mediump int  ui_one;\n\n"
 				   "void myfunc (void)\n"
 				   "{\n"
 				   "    for (int i = 0; i < 2; i++)\n"
 				   "    {\n"
 				   "        if (i > 0)\n"
 				   "            ${DISCARD};\n"
 				   "    }\n"
 				   "}\n\n"
 				   "void main (void)\n"
 				   "{\n"
 				   "    o_color = v_color;\n"
 				   "    myfunc();\n"
 				   "}\n";

 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 static const char* getTemplateName (DiscardTemplate variant)
 {
 	switch (variant)
 	{
 		case DISCARDTEMPLATE_MAIN_BASIC:			return "basic";
 		case DISCARDTEMPLATE_FUNCTION_BASIC:		return "function";
 		case DISCARDTEMPLATE_MAIN_STATIC_LOOP:		return "static_loop";
 		case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:		return "dynamic_loop";
 		case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:	return "function_static_loop";
 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 static const char* getModeName (DiscardMode mode)
 {
 	switch (mode)
 	{
 		case DISCARDMODE_ALWAYS:	return "always";
 		case DISCARDMODE_NEVER:		return "never";
 		case DISCARDMODE_UNIFORM:	return "uniform";
 		case DISCARDMODE_DYNAMIC:	return "dynamic";
 		case DISCARDMODE_TEXTURE:	return "texture";
 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 static const char* getTemplateDesc (DiscardTemplate variant)
 {
 	switch (variant)
 	{
 		case DISCARDTEMPLATE_MAIN_BASIC:			return "main";
 		case DISCARDTEMPLATE_FUNCTION_BASIC:		return "function";
 		case DISCARDTEMPLATE_MAIN_STATIC_LOOP:		return "static loop";
 		case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:		return "dynamic loop";
 		case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:	return "static loop in function";
 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 static const char* getModeDesc (DiscardMode mode)
 {
 	switch (mode)
 	{
 		case DISCARDMODE_ALWAYS:	return "Always discard";
 		case DISCARDMODE_NEVER:		return "Never discard";
 		case DISCARDMODE_UNIFORM:	return "Discard based on uniform value";
 		case DISCARDMODE_DYNAMIC:	return "Discard based on varying values";
 		case DISCARDMODE_TEXTURE:	return "Discard based on texture value";
 		default:
 			DE_ASSERT(DE_FALSE);
 			return DE_NULL;
 	}
 }

 ShaderDiscardCase* makeDiscardCase (Context& context, DiscardTemplate tmpl, DiscardMode mode)
 {
 	StringTemplate shaderTemplate(getTemplate(tmpl));

 	map<string, string> params;

 	switch (mode)
 	{
 		case DISCARDMODE_ALWAYS:	params["DISCARD"] = "discard";										break;
 		case DISCARDMODE_NEVER:		params["DISCARD"] = "if (false) discard";							break;
 		case DISCARDMODE_UNIFORM:	params["DISCARD"] = "if (ui_one > 0) discard";						break;
 		case DISCARDMODE_DYNAMIC:	params["DISCARD"] = "if (v_coords.x+v_coords.y > 0.0) discard";		break;
 		case DISCARDMODE_TEXTURE:	params["DISCARD"] = "if (texture(ut_brick, v_coords.xy*0.25+0.5).x < 0.7) discard";	break;
 		default:
 			DE_ASSERT(DE_FALSE);
 			break;
 	}

 	string name			= string(getTemplateName(tmpl)) + "_" + getModeName(mode);
 	string description	= string(getModeDesc(mode)) + " in " + getTemplateDesc(tmpl);

 	return new ShaderDiscardCase(context, name.c_str(), description.c_str(), shaderTemplate.specialize(params).c_str(), getEvalFunc(mode), mode == DISCARDMODE_TEXTURE);
 }

 void ShaderDiscardTests::init (void)
 {
 	for (int tmpl = 0; tmpl < DISCARDTEMPLATE_LAST; tmpl++)
 		for (int mode = 0; mode < DISCARDMODE_LAST; mode++)
 			addChild(makeDiscardCase(m_context, (DiscardTemplate)tmpl, (DiscardMode)mode));
 }

 } // Functional
 } // gles3
 } // deqp
	/*-------------------------------------------------------------------------
	* drawElements Quality Program OpenGL ES 3.0 Module
	* -------------------------------------------------
	*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Shader discard statement tests.
	//--------------------------------------------------------------------*/

	#include "es3fShaderDiscardTests.hpp"
	#include "glsShaderRenderCase.hpp"
	#include "tcuStringTemplate.hpp"
	#include "gluTexture.hpp"

	#include <map>
	#include <sstream>
	#include <string>

	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"

	using tcu::StringTemplate;

	using std::map;
	using std::string;
	using std::ostringstream;

	using namespace glu;
	using namespace deqp::gls;

	namespace deqp
	{
	namespace gles3
	{
	namespace Functional
	{

	class ShaderDiscardCase : public ShaderRenderCase
	{
	public:
	ShaderDiscardCase (Context& context, const char* name, const char* description, const char* shaderSource, ShaderEvalFunc evalFunc, bool usesTexture);
	virtual ~ShaderDiscardCase (void);

	void init (void);
	void deinit (void);

	void setupUniforms (int programID, const tcu::Vec4& constCoords);

	private:
	bool m_usesTexture;
	glu::Texture2D* m_brickTexture;
	};

	ShaderDiscardCase::ShaderDiscardCase (Context& context, const char* name, const char* description, const char* shaderSource, ShaderEvalFunc evalFunc, bool usesTexture)
	: ShaderRenderCase (context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, description, false, evalFunc)
	, m_usesTexture (usesTexture)
	, m_brickTexture (DE_NULL)
	{
	m_fragShaderSource = shaderSource;
	m_vertShaderSource =
	"#version 300 es\n"
	"in highp vec4 a_position;\n"
	"in highp vec4 a_coords;\n"
	"out mediump vec4 v_color;\n"
	"out mediump vec4 v_coords;\n\n"
	"void main (void)\n"
	"{\n"
	" gl_Position = a_position;\n"
	" v_color = vec4(a_coords.xyz, 1.0);\n"
	" v_coords = a_coords;\n"
	"}\n";
	}

	ShaderDiscardCase::~ShaderDiscardCase (void)
	{
	delete m_brickTexture;
	}

	void ShaderDiscardCase::init (void)
	{
	if (m_usesTexture)
	{
	m_brickTexture = glu::Texture2D::create(m_renderCtx, m_ctxInfo, m_testCtx.getArchive(), "data/brick.png");
	m_textures.push_back(TextureBinding(m_brickTexture, tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
	tcu::Sampler::LINEAR, tcu::Sampler::LINEAR)));
	}
	gls::ShaderRenderCase::init();
	}

	void ShaderDiscardCase::deinit (void)
	{
	gls::ShaderRenderCase::deinit();
	delete m_brickTexture;
	m_brickTexture = DE_NULL;
	}

	void ShaderDiscardCase::setupUniforms (int programID, const tcu::Vec4&)
	{
	const glw::Functions& gl = m_renderCtx.getFunctions();
	gl.uniform1i(gl.getUniformLocation(programID, "ut_brick"), 0);
	}

	ShaderDiscardTests::ShaderDiscardTests (Context& context)
	: TestCaseGroup(context, "discard", "Discard statement tests")
	{
	}

	ShaderDiscardTests::~ShaderDiscardTests (void)
	{
	}

	enum DiscardMode
	{
	DISCARDMODE_ALWAYS = 0,
	DISCARDMODE_NEVER,
	DISCARDMODE_UNIFORM,
	DISCARDMODE_DYNAMIC,
	DISCARDMODE_TEXTURE,

	DISCARDMODE_LAST
	};

	enum DiscardTemplate
	{
	DISCARDTEMPLATE_MAIN_BASIC = 0,
	DISCARDTEMPLATE_FUNCTION_BASIC,
	DISCARDTEMPLATE_MAIN_STATIC_LOOP,
	DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP,
	DISCARDTEMPLATE_FUNCTION_STATIC_LOOP,

	DISCARDTEMPLATE_LAST
	};

	// Evaluation functions
	inline void evalDiscardAlways (ShaderEvalContext& c) { c.discard(); }
	inline void evalDiscardNever (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
	inline void evalDiscardDynamic (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); if (c.coords.x()+c.coords.y() > 0.0f) c.discard(); }

	inline void evalDiscardTexture (ShaderEvalContext& c)
	{
	c.color.xyz() = c.coords.swizzle(0,1,2);
	if (c.texture2D(0, c.coords.swizzle(0,1) * 0.25f + 0.5f).x() < 0.7f)
	c.discard();
	}

	static ShaderEvalFunc getEvalFunc (DiscardMode mode)
	{
	switch (mode)
	{
	case DISCARDMODE_ALWAYS: return evalDiscardAlways;
	case DISCARDMODE_NEVER: return evalDiscardNever;
	case DISCARDMODE_UNIFORM: return evalDiscardAlways;
	case DISCARDMODE_DYNAMIC: return evalDiscardDynamic;
	case DISCARDMODE_TEXTURE: return evalDiscardTexture;
	default:
	DE_ASSERT(DE_FALSE);
	return evalDiscardAlways;
	}
	}

	static const char* getTemplate (DiscardTemplate variant)
	{
	switch (variant)
	{
	case DISCARDTEMPLATE_MAIN_BASIC:
	return "#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"in mediump vec4 v_coords;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"uniform sampler2D ut_brick;\n"
	"uniform mediump int ui_one;\n\n"
	"void main (void)\n"
	"{\n"
	" o_color = v_color;\n"
	" ${DISCARD};\n"
	"}\n";

	case DISCARDTEMPLATE_FUNCTION_BASIC:
	return "#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"in mediump vec4 v_coords;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"uniform sampler2D ut_brick;\n"
	"uniform mediump int ui_one;\n\n"
	"void myfunc (void)\n"
	"{\n"
	" ${DISCARD};\n"
	"}\n\n"
	"void main (void)\n"
	"{\n"
	" o_color = v_color;\n"
	" myfunc();\n"
	"}\n";

	case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
	return "#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"in mediump vec4 v_coords;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"uniform sampler2D ut_brick;\n"
	"uniform mediump int ui_one;\n\n"
	"void main (void)\n"
	"{\n"
	" o_color = v_color;\n"
	" for (int i = 0; i < 2; i++)\n"
	" {\n"
	" if (i > 0)\n"
	" ${DISCARD};\n"
	" }\n"
	"}\n";

	case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
	return "#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"in mediump vec4 v_coords;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"uniform sampler2D ut_brick;\n"
	"uniform mediump int ui_one;\n"
	"uniform mediump int ui_two;\n\n"
	"void main (void)\n"
	"{\n"
	" o_color = v_color;\n"
	" for (int i = 0; i < ui_two; i++)\n"
	" {\n"
	" if (i > 0)\n"
	" ${DISCARD};\n"
	" }\n"
	"}\n";

	case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
	return "#version 300 es\n"
	"in mediump vec4 v_color;\n"
	"in mediump vec4 v_coords;\n"
	"layout(location = 0) out mediump vec4 o_color;\n"
	"uniform sampler2D ut_brick;\n"
	"uniform mediump int ui_one;\n\n"
	"void myfunc (void)\n"
	"{\n"
	" for (int i = 0; i < 2; i++)\n"
	" {\n"
	" if (i > 0)\n"
	" ${DISCARD};\n"
	" }\n"
	"}\n\n"
	"void main (void)\n"
	"{\n"
	" o_color = v_color;\n"
	" myfunc();\n"
	"}\n";

	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	static const char* getTemplateName (DiscardTemplate variant)
	{
	switch (variant)
	{
	case DISCARDTEMPLATE_MAIN_BASIC: return "basic";
	case DISCARDTEMPLATE_FUNCTION_BASIC: return "function";
	case DISCARDTEMPLATE_MAIN_STATIC_LOOP: return "static_loop";
	case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP: return "dynamic_loop";
	case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP: return "function_static_loop";
	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	static const char* getModeName (DiscardMode mode)
	{
	switch (mode)
	{
	case DISCARDMODE_ALWAYS: return "always";
	case DISCARDMODE_NEVER: return "never";
	case DISCARDMODE_UNIFORM: return "uniform";
	case DISCARDMODE_DYNAMIC: return "dynamic";
	case DISCARDMODE_TEXTURE: return "texture";
	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	static const char* getTemplateDesc (DiscardTemplate variant)
	{
	switch (variant)
	{
	case DISCARDTEMPLATE_MAIN_BASIC: return "main";
	case DISCARDTEMPLATE_FUNCTION_BASIC: return "function";
	case DISCARDTEMPLATE_MAIN_STATIC_LOOP: return "static loop";
	case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP: return "dynamic loop";
	case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP: return "static loop in function";
	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	static const char* getModeDesc (DiscardMode mode)
	{
	switch (mode)
	{
	case DISCARDMODE_ALWAYS: return "Always discard";
	case DISCARDMODE_NEVER: return "Never discard";
	case DISCARDMODE_UNIFORM: return "Discard based on uniform value";
	case DISCARDMODE_DYNAMIC: return "Discard based on varying values";
	case DISCARDMODE_TEXTURE: return "Discard based on texture value";
	default:
	DE_ASSERT(DE_FALSE);
	return DE_NULL;
	}
	}

	ShaderDiscardCase* makeDiscardCase (Context& context, DiscardTemplate tmpl, DiscardMode mode)
	{
	StringTemplate shaderTemplate(getTemplate(tmpl));

	map<string, string> params;

	switch (mode)
	{
	case DISCARDMODE_ALWAYS: params["DISCARD"] = "discard"; break;
	case DISCARDMODE_NEVER: params["DISCARD"] = "if (false) discard"; break;
	case DISCARDMODE_UNIFORM: params["DISCARD"] = "if (ui_one > 0) discard"; break;
	case DISCARDMODE_DYNAMIC: params["DISCARD"] = "if (v_coords.x+v_coords.y > 0.0) discard"; break;
	case DISCARDMODE_TEXTURE: params["DISCARD"] = "if (texture(ut_brick, v_coords.xy*0.25+0.5).x < 0.7) discard"; break;
	default:
	DE_ASSERT(DE_FALSE);
	break;
	}

	string name = string(getTemplateName(tmpl)) + "_" + getModeName(mode);
	string description = string(getModeDesc(mode)) + " in " + getTemplateDesc(tmpl);

	return new ShaderDiscardCase(context, name.c_str(), description.c_str(), shaderTemplate.specialize(params).c_str(), getEvalFunc(mode), mode == DISCARDMODE_TEXTURE);
	}

	void ShaderDiscardTests::init (void)
	{
	for (int tmpl = 0; tmpl < DISCARDTEMPLATE_LAST; tmpl++)
	for (int mode = 0; mode < DISCARDMODE_LAST; mode++)
	addChild(makeDiscardCase(m_context, (DiscardTemplate)tmpl, (DiscardMode)mode));
	}

	} // Functional
	} // gles3
	} // deqp