| #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 |