Merge gerrit/vulkan-cts-1.0.1 into gerrit/vulkan-cts-1.0-dev
[platform/upstream/VK-GL-CTS.git] / framework / opengl / gluShaderLibrary.hpp
1 #ifndef _GLUSHADERLIBRARY_HPP
2 #define _GLUSHADERLIBRARY_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program OpenGL ES Utilities
5  * ------------------------------------------------
6  *
7  * Copyright 2015 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Shader .test file utilities.
24  *//*--------------------------------------------------------------------*/
25
26 #include "gluDefs.hpp"
27 #include "gluVarType.hpp"
28 #include "gluShaderProgram.hpp"
29 #include "tcuTestCase.hpp"
30
31 #include <string>
32 #include <vector>
33
34 namespace glu
35 {
36 namespace sl
37 {
38
39 enum CaseType
40 {
41         CASETYPE_COMPLETE = 0,          //!< Has all shaders specified separately.
42         CASETYPE_VERTEX_ONLY,           //!< "Both" case, vertex shader sub case.
43         CASETYPE_FRAGMENT_ONLY,         //!< "Both" case, fragment shader sub case.
44
45         CASETYPE_LAST
46 };
47
48 enum ExpectResult
49 {
50         EXPECT_PASS = 0,
51         EXPECT_COMPILE_FAIL,
52         EXPECT_LINK_FAIL,
53         EXPECT_COMPILE_LINK_FAIL,
54         EXPECT_VALIDATION_FAIL,
55         EXPECT_BUILD_SUCCESSFUL,
56
57         EXPECT_LAST
58 };
59
60 struct Value
61 {
62         union Element
63         {
64                 float           float32;
65                 deInt32         int32;
66                 deInt32         bool32;
67         };
68
69         VarType                                 type;
70         std::string                             name;
71         std::vector<Element>    elements;               // Scalar values (variable.varType.getScalarSize() * #values).
72 };
73
74 struct ValueBlock
75 {
76         std::vector<Value>              inputs;
77         std::vector<Value>              outputs;
78         std::vector<Value>              uniforms;
79 };
80
81 struct RequiredCapability
82 {
83         deUint32                                enumName;
84         int                                             referenceValue;
85
86         RequiredCapability (void)
87                 : enumName                      (0u)
88                 , referenceValue        (0)
89         {
90         }
91
92         RequiredCapability (deUint32 enumName_, int referenceValue_)
93                 : enumName                      (enumName_)
94                 , referenceValue        (referenceValue_)
95         {
96         }
97 };
98
99 struct RequiredExtension
100 {
101         std::vector<std::string>        alternatives;           // One or more extensions, at least one (but not all) must be supported
102         deUint32                                        effectiveStages;        // Bitfield of shader stages requiring this extension
103
104         RequiredExtension (const std::vector<std::string>&      alternatives_,
105                                            deUint32                                                     effectiveStages_)
106                 : alternatives          (alternatives_)
107                 , effectiveStages       (effectiveStages_)
108         {
109         }
110
111                 RequiredExtension (const std::string&   extension,
112                                                    deUint32                             effectiveStages_)
113                 : effectiveStages       (effectiveStages_)
114         {
115                 alternatives.push_back(extension);
116         }
117
118         RequiredExtension (void)
119                 : effectiveStages       (0u)
120         {
121         }
122 };
123
124 struct ProgramSpecification
125 {
126         glu::ProgramSources                             sources;
127         std::vector<RequiredExtension>  requiredExtensions;
128         deUint32                                                activeStages;   // Has an effect only if sources.separable == true, must be 0 otherwise
129
130         ProgramSpecification (void)
131                 : activeStages(0u)
132         {
133         }
134 };
135
136 struct ShaderCaseSpecification
137 {
138         CaseType                                                        caseType;
139         ExpectResult                                            expectResult;
140         glu::GLSLVersion                                        targetVersion;
141
142         // \todo [pyry] Clean this up
143         std::vector<RequiredCapability>         requiredCaps;
144         bool                                                            fullGLSLES100Required;
145
146         ValueBlock                                                      values;
147         std::vector<ProgramSpecification>       programs;
148
149         ShaderCaseSpecification (void)
150                 : caseType                              (CASETYPE_LAST)
151                 , expectResult                  (EXPECT_LAST)
152                 , targetVersion                 (glu::GLSL_VERSION_LAST)
153                 , fullGLSLES100Required (false)
154         {
155         }
156 };
157
158 bool    isValid         (const ValueBlock& block);
159 bool    isValid         (const ShaderCaseSpecification& spec);
160
161 class ShaderCaseFactory
162 {
163 public:
164         virtual tcu::TestCaseGroup*     createGroup     (const std::string& name, const std::string& description, const std::vector<tcu::TestNode*>& children) = 0;
165         virtual tcu::TestCase*          createCase      (const std::string& name, const std::string& description, const ShaderCaseSpecification& spec) = 0;
166 };
167
168 std::vector<tcu::TestNode*>             parseFile       (const tcu::Archive& archive, const std::string& filename, ShaderCaseFactory* caseFactory);
169
170 // Specialization utilties
171
172 struct ProgramSpecializationParams
173 {
174         const ShaderCaseSpecification&                  caseSpec;
175         const std::vector<RequiredExtension>    requiredExtensions;     // Extensions, must be resolved to single ext per entry
176         const int                                                               maxPatchVertices;       // Used by tess shaders only
177
178         ProgramSpecializationParams (const ShaderCaseSpecification&                     caseSpec_,
179                                                                  const std::vector<RequiredExtension>&  requiredExtensions_,
180                                                                  int                                                                    maxPatchVertices_)
181                 : caseSpec                              (caseSpec_)
182                 , requiredExtensions    (requiredExtensions_)
183                 , maxPatchVertices              (maxPatchVertices_)
184         {
185         }
186 };
187
188 void                    genCompareFunctions                     (std::ostringstream& stream, const ValueBlock& valueBlock, bool useFloatTypes);
189 std::string             injectExtensionRequirements     (const std::string& baseCode, const std::vector<RequiredExtension>& extensions, ShaderType shaderType);
190
191 // Other utilities
192
193 void                    dumpValues                                      (tcu::TestLog& log, const ValueBlock& values, int arrayNdx);
194
195 } // sl
196 } // glu
197
198 #endif // _GLUSHADERLIBRARY_HPP