external/openglcts/modules/gl/gl4cShaderBallotTests.hpp

#ifndef _GL4CSHADERBALLOTTESTS_HPP
#define _GL4CSHADERBALLOTTESTS_HPP
/*-------------------------------------------------------------------------
* OpenGL Conformance Test Suite
* -----------------------------
*
* Copyright (c) 2014-2017 The Khronos Group Inc.
*
* 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  gl4cShaderBallotTests.hpp
* \brief Conformance tests for the ARB_shader_ballot functionality.
*/ /*-------------------------------------------------------------------*/

#include "esextcTestCaseBase.hpp"
#include "glcTestCase.hpp"
#include "gluShaderProgram.hpp"

#include <map>
#include <vector>

namespace gl4cts
{
class ShaderBallotBaseTestCase : public glcts::TestCaseBase
{
public:
	class ShaderPipeline
	{
	private:
		glu::ShaderProgram* m_programRender;
		glu::ShaderProgram* m_programCompute;
		glu::ShaderType		m_testedShader;

		std::vector<std::string> m_shaders[glu::SHADERTYPE_LAST];
		char**					 m_shaderChunks[glu::SHADERTYPE_LAST];

		std::map<std::string, std::string> m_specializationMap;

		void renderQuad(deqp::Context& context);
		void executeComputeShader(deqp::Context& context);

	public:
		ShaderPipeline(glu::ShaderType testedShader, const std::string& contentSnippet,
					   std::map<std::string, std::string> specMap = std::map<std::string, std::string>());
		~ShaderPipeline();

		const char* const* getShaderParts(glu::ShaderType shaderType) const;
		unsigned int getShaderPartsCount(glu::ShaderType shaderType) const;

		void use(deqp::Context& context);

		inline void setShaderPrograms(glu::ShaderProgram* programRender, glu::ShaderProgram* programCompute)
		{
			m_programRender  = programRender;
			m_programCompute = programCompute;
		}

		inline const std::map<std::string, std::string>& getSpecializationMap() const
		{
			return m_specializationMap;
		}

		void test(deqp::Context& context);
	};

protected:
	/* Protected methods */
	void createShaderPrograms(ShaderPipeline& pipeline);

	/* Protected members*/
	std::vector<ShaderPipeline*> m_shaderPipelines;

	typedef std::vector<ShaderPipeline*>::iterator ShaderPipelineIter;

public:
	/* Public methods */
	ShaderBallotBaseTestCase(deqp::Context& context, const char* name, const char* description)
		: TestCaseBase(context, glcts::ExtParameters(glu::GLSL_VERSION_450, glcts::EXTENSIONTYPE_EXT), name,
					   description)
	{
	}

	virtual ~ShaderBallotBaseTestCase();

	static bool validateScreenPixels(deqp::Context& context, tcu::Vec4 desiredColor, tcu::Vec4 ignoredColor);
	static bool validateScreenPixelsSameColor(deqp::Context& context, tcu::Vec4 ignoredColor);
	static bool validateColor(tcu::Vec4 testedColor, tcu::Vec4 desiredColor);
};

/** Test verifies availability of new build-in features
**/
class ShaderBallotAvailabilityTestCase : public ShaderBallotBaseTestCase
{
public:
	/* Public methods */
	ShaderBallotAvailabilityTestCase(deqp::Context& context);

	void init();

	tcu::TestNode::IterateResult iterate();
};

/** Test verifies values of gl_SubGroup*MaskARB variables
**/
class ShaderBallotBitmasksTestCase : public ShaderBallotBaseTestCase
{
public:
	/* Public methods */
	ShaderBallotBitmasksTestCase(deqp::Context& context);

	void init();

	tcu::TestNode::IterateResult iterate();

protected:
	/* Protected members*/
	std::map<std::string, std::string> m_maskVars;

	typedef std::map<std::string, std::string>::iterator MaskVarIter;
};

/** Test verifies ballotARB calls and returned results
**/
class ShaderBallotFunctionBallotTestCase : public ShaderBallotBaseTestCase
{
public:
	/* Public methods */
	ShaderBallotFunctionBallotTestCase(deqp::Context& context);

	void init();

	tcu::TestNode::IterateResult iterate();
};

/** Test verifies readInvocationARB and readFirstInvocationARB function calls
**/
class ShaderBallotFunctionReadTestCase : public ShaderBallotBaseTestCase
{
public:
	/* Public methods */
	ShaderBallotFunctionReadTestCase(deqp::Context& context);

	void init();

	tcu::TestNode::IterateResult iterate();
};

class ShaderBallotTests : public deqp::TestCaseGroup
{
public:
	ShaderBallotTests(deqp::Context& context);
	void init(void);

private:
	ShaderBallotTests(const ShaderBallotTests& other);
	ShaderBallotTests& operator=(const ShaderBallotTests& other);
};

} /* gl4cts namespace */

#endif // _GL4CSHADERBALLOTTESTS_HPP