blob: f2ce73fd6c1fd439535e8c1b9836a4e1f7fc4eea [file] [log] [blame]
#ifndef _GLUSHADERLIBRARY_HPP
#define _GLUSHADERLIBRARY_HPP
/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2015 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 .test file utilities.
*//*--------------------------------------------------------------------*/
#include "gluDefs.hpp"
#include "gluVarType.hpp"
#include "gluShaderProgram.hpp"
#include "tcuTestCase.hpp"
#include <string>
#include <vector>
namespace glu
{
namespace sl
{
enum CaseType
{
CASETYPE_COMPLETE = 0, //!< Has all shaders specified separately.
CASETYPE_VERTEX_ONLY, //!< "Both" case, vertex shader sub case.
CASETYPE_FRAGMENT_ONLY, //!< "Both" case, fragment shader sub case.
CASETYPE_LAST
};
enum ExpectResult
{
EXPECT_PASS = 0,
EXPECT_COMPILE_FAIL,
EXPECT_LINK_FAIL,
EXPECT_COMPILE_LINK_FAIL,
EXPECT_VALIDATION_FAIL,
EXPECT_BUILD_SUCCESSFUL,
EXPECT_LAST
};
enum OutputType
{
OUTPUT_RESULT = 0,
OUTPUT_COLOR,
OUTPUT_LAST
};
struct Value
{
union Element
{
float float32;
int32_t int32;
int32_t bool32;
};
VarType type;
std::string name;
std::vector<Element> elements; // Scalar values (variable.varType.getScalarSize() * #values).
};
struct ValueBlock
{
std::vector<Value> inputs;
std::vector<Value> outputs;
std::vector<Value> uniforms;
};
enum CapabilityType
{
CAPABILITY_LIMIT = 0,
CAPABILITY_FLAG,
CAPABILITY_LAST
};
enum CapabilityFlag
{
CAPABILITY_FULL_GLSL_ES_100_SUPPORT,
CAPABILITY_ONLY_GLSL_ES_100_SUPPORT, // only ES2, no ES3 capability
CAPABILITY_EXACTLY_ONE_DRAW_BUFFER // gl_MaxDrawBuffers is exactly 1
};
struct RequiredCapability
{
CapabilityType type;
union
{
CapabilityFlag flagName;
uint32_t enumName;
};
int referenceValue;
RequiredCapability(CapabilityFlag flagName_)
: type(CAPABILITY_FLAG)
, flagName(flagName_)
, referenceValue(0) // not used
{
}
RequiredCapability(uint32_t enumName_, int referenceValue_)
: type(CAPABILITY_LIMIT)
, enumName(enumName_)
, referenceValue(referenceValue_)
{
}
};
struct RequiredExtension
{
std::vector<std::string> alternatives; // One or more extensions, at least one (but not all) must be supported
uint32_t effectiveStages; // Bitfield of shader stages requiring this extension
RequiredExtension(const std::vector<std::string> &alternatives_, uint32_t effectiveStages_)
: alternatives(alternatives_)
, effectiveStages(effectiveStages_)
{
}
RequiredExtension(const std::string &extension, uint32_t effectiveStages_) : effectiveStages(effectiveStages_)
{
alternatives.push_back(extension);
}
RequiredExtension(void) : effectiveStages(0u)
{
}
};
struct ProgramSpecification
{
glu::ProgramSources sources;
std::vector<RequiredExtension> requiredExtensions;
uint32_t activeStages; // Has an effect only if sources.separable == true, must be 0 otherwise
ProgramSpecification(void) : activeStages(0u)
{
}
};
struct ShaderCaseSpecification
{
CaseType caseType;
ExpectResult expectResult;
OutputType outputType;
DataType outputFormat;
glu::GLSLVersion targetVersion;
std::vector<RequiredCapability> requiredCaps;
ValueBlock values;
std::vector<ProgramSpecification> programs;
ShaderCaseSpecification(void)
: caseType(CASETYPE_LAST)
, expectResult(EXPECT_LAST)
, outputType(OUTPUT_RESULT)
, outputFormat(TYPE_LAST)
, targetVersion(glu::GLSL_VERSION_LAST)
{
}
};
bool isValid(const ValueBlock &block);
bool isValid(const ShaderCaseSpecification &spec);
bool isCapabilityRequired(CapabilityFlag capabilityFlag, const ShaderCaseSpecification &spec);
class ShaderCaseFactory
{
public:
virtual ~ShaderCaseFactory()
{
}
virtual tcu::TestCaseGroup *createGroup(const std::string &name, const std::string &description,
const std::vector<tcu::TestNode *> &children) = 0;
virtual tcu::TestCase *createCase(const std::string &name, const std::string &description,
const ShaderCaseSpecification &spec) = 0;
};
std::vector<tcu::TestNode *> parseFile(const tcu::Archive &archive, const std::string &filename,
ShaderCaseFactory *caseFactory);
// Specialization utilties
struct ProgramSpecializationParams
{
const ShaderCaseSpecification &caseSpec;
const std::vector<RequiredExtension> requiredExtensions; // Extensions, must be resolved to single ext per entry
const int maxPatchVertices; // Used by tess shaders only
ProgramSpecializationParams(const ShaderCaseSpecification &caseSpec_,
const std::vector<RequiredExtension> &requiredExtensions_, int maxPatchVertices_)
: caseSpec(caseSpec_)
, requiredExtensions(requiredExtensions_)
, maxPatchVertices(maxPatchVertices_)
{
}
};
void genCompareFunctions(std::ostringstream &stream, const ValueBlock &valueBlock, bool useFloatTypes);
std::string injectExtensionRequirements(const std::string &baseCode, const std::vector<RequiredExtension> &extensions,
ShaderType shaderType);
// Other utilities
void dumpValues(tcu::TestLog &log, const ValueBlock &values, int arrayNdx);
} // namespace sl
} // namespace glu
#endif // _GLUSHADERLIBRARY_HPP