#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;
|
deInt32 int32;
|
deInt32 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;
|
deUint32 enumName;
|
};
|
|
int referenceValue;
|
|
RequiredCapability (CapabilityFlag flagName_)
|
: type (CAPABILITY_FLAG)
|
, flagName (flagName_)
|
, referenceValue (0) // not used
|
{
|
}
|
|
RequiredCapability (deUint32 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
|
deUint32 effectiveStages; // Bitfield of shader stages requiring this extension
|
|
RequiredExtension (const std::vector<std::string>& alternatives_,
|
deUint32 effectiveStages_)
|
: alternatives (alternatives_)
|
, effectiveStages (effectiveStages_)
|
{
|
}
|
|
RequiredExtension (const std::string& extension,
|
deUint32 effectiveStages_)
|
: effectiveStages (effectiveStages_)
|
{
|
alternatives.push_back(extension);
|
}
|
|
RequiredExtension (void)
|
: effectiveStages (0u)
|
{
|
}
|
};
|
|
struct ProgramSpecification
|
{
|
glu::ProgramSources sources;
|
std::vector<RequiredExtension> requiredExtensions;
|
deUint32 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 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);
|
|
} // sl
|
} // glu
|
|
#endif // _GLUSHADERLIBRARY_HPP
|
