blob: 4f12a6c5d3498f8cb1a027c14c80cbad178b4e30 [file] [log] [blame]
#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