1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
5 * Copyright 2016 The Android Open Source Project
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief Negative Shader Storage Tests
22 *//*--------------------------------------------------------------------*/
24 #include "es31fNegativeShaderStorageTests.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "glwDefs.hpp"
28 #include "glwEnums.hpp"
36 namespace NegativeTestShared
41 void verifyProgram(NegativeTestContext& ctx, glu::ProgramSources sources)
43 tcu::TestLog& log = ctx.getLog();
44 const glu::ShaderProgram program (ctx.getRenderContext(), sources);
45 bool testFailed = false;
49 testFailed = program.getProgramInfo().linkOk;
53 const char* const message("Program was not expected to link.");
54 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
59 const char* getShaderExtensionDeclaration (glw::GLenum glShaderType)
63 case GL_TESS_CONTROL_SHADER:
64 case GL_TESS_EVALUATION_SHADER: return "#extension GL_EXT_tessellation_shader : require\n";
65 case GL_GEOMETRY_SHADER: return "#extension GL_EXT_geometry_shader : require\n";
71 glu::ShaderType getGLUShaderType (glw::GLenum glShaderType)
75 case GL_VERTEX_SHADER: return glu::SHADERTYPE_VERTEX;
76 case GL_FRAGMENT_SHADER: return glu::SHADERTYPE_FRAGMENT;
77 case GL_TESS_CONTROL_SHADER: return glu::SHADERTYPE_TESSELLATION_CONTROL;
78 case GL_TESS_EVALUATION_SHADER: return glu::SHADERTYPE_TESSELLATION_EVALUATION;
79 case GL_GEOMETRY_SHADER: return glu::SHADERTYPE_GEOMETRY;
80 case GL_COMPUTE_SHADER: return glu::SHADERTYPE_COMPUTE;
82 DE_FATAL("Unknown shader type");
83 return glu::SHADERTYPE_LAST;
87 glw::GLenum getMaxSSBlockSizeEnum (glw::GLenum glShaderType)
91 case GL_VERTEX_SHADER: return GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS;
92 case GL_FRAGMENT_SHADER: return GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS;
93 case GL_TESS_CONTROL_SHADER: return GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS;
94 case GL_TESS_EVALUATION_SHADER: return GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS;
95 case GL_GEOMETRY_SHADER: return GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS;
96 case GL_COMPUTE_SHADER: return GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS;
98 DE_FATAL("Unknown shader type");
103 int getMaxSSBlockSize (NegativeTestContext& ctx, glw::GLenum glShaderType)
106 ctx.glGetIntegerv(getMaxSSBlockSizeEnum(glShaderType), &maxSSBlocks);
111 std::string genBlockSource (NegativeTestContext& ctx, deInt64 numSSBlocks, glw::GLenum shaderType)
113 const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
114 const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
115 std::ostringstream source;
117 source << glu::getGLSLVersionDeclaration(version) << "\n"
118 << ((isES32) ? "" : getShaderExtensionDeclaration(shaderType));
122 case GL_VERTEX_SHADER:
123 case GL_FRAGMENT_SHADER:
126 case GL_COMPUTE_SHADER:
127 source << "layout (local_size_x = 1) in;\n";
130 case GL_GEOMETRY_SHADER:
131 source << "layout(points) in;\n"
132 << "layout(line_strip, max_vertices = 3) out;\n";
135 case GL_TESS_CONTROL_SHADER:
136 source << "layout(vertices = 10) out;\n";
139 case GL_TESS_EVALUATION_SHADER:
140 source << "layout(triangles) in;\n";
144 DE_FATAL("Unknown shader type");
149 << "layout(std430, binding = 0) buffer Block {\n"
151 << "} sb_in[" << numSSBlocks << "];\n"
152 << "void main(void) { sb_in[0].value = 1; }\n";
157 std::string genCommonSource (NegativeTestContext& ctx, glw::GLenum shaderType)
159 const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
160 const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
161 std::ostringstream source;
163 source << glu::getGLSLVersionDeclaration(version) << "\n"
164 << ((isES32) ? "" : getShaderExtensionDeclaration(shaderType));
168 case GL_TESS_CONTROL_SHADER:
169 source << "layout(vertices = 3) out;\n"
170 << "void main() {}\n";
173 case GL_TESS_EVALUATION_SHADER:
174 source << "layout(triangles, equal_spacing, cw) in;\n"
175 << "void main() {}\n";
179 source << "void main() {}\n";
186 int genMaxSSBlocksSource (NegativeTestContext& ctx, glw::GLenum glShaderType, glu::ProgramSources& sources)
188 int maxSSBlocks = getMaxSSBlockSize(ctx, glShaderType);
189 const std::string shaderSrc = genBlockSource(ctx, (maxSSBlocks), glShaderType);
191 sources.sources[getGLUShaderType(glShaderType)].push_back(shaderSrc);
196 void block_number_limits (NegativeTestContext& ctx)
198 const glw::GLenum glShaderTypes[] =
202 GL_TESS_CONTROL_SHADER,
203 GL_TESS_EVALUATION_SHADER,
208 const std::string vertSource = genCommonSource(ctx, GL_VERTEX_SHADER);
209 const std::string fragSource = genCommonSource(ctx, GL_FRAGMENT_SHADER);
210 const std::string tessControlSource = genCommonSource(ctx, GL_TESS_CONTROL_SHADER);
211 const std::string tessEvalSource = genCommonSource(ctx, GL_TESS_EVALUATION_SHADER);
213 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(glShaderTypes); ndx++)
215 ctx.beginSection("maxShaderStorageBlocks: Exceed limits");
217 if (!ctx.isShaderSupported(static_cast<glu::ShaderType>(getGLUShaderType(glShaderTypes[ndx]))))
223 int maxSSBlocks = getMaxSSBlockSize(ctx, glShaderTypes[ndx]);
224 std::string source = genBlockSource(ctx, maxSSBlocks+1, glShaderTypes[ndx]);
226 glu::ProgramSources sources;
228 if (maxSSBlocks == 0)
234 switch (glShaderTypes[ndx])
236 case GL_VERTEX_SHADER:
237 sources << glu::VertexSource(source)
238 << glu::FragmentSource(fragSource);
241 case GL_FRAGMENT_SHADER:
242 sources << glu::VertexSource(vertSource)
243 << glu::FragmentSource(source);
246 case GL_TESS_CONTROL_SHADER:
247 sources << glu::VertexSource(vertSource)
248 << glu::FragmentSource(fragSource)
249 << glu::TessellationControlSource(source)
250 << glu::TessellationEvaluationSource(tessEvalSource);
253 case GL_TESS_EVALUATION_SHADER:
254 sources << glu::VertexSource(vertSource)
255 << glu::FragmentSource(fragSource)
256 << glu::TessellationControlSource(tessControlSource)
257 << glu::TessellationEvaluationSource(source);
260 case GL_GEOMETRY_SHADER:
261 sources << glu::VertexSource(vertSource)
262 << glu::FragmentSource(fragSource)
263 << glu::GeometrySource(source);
266 case GL_COMPUTE_SHADER:
267 sources << glu::ComputeSource(source);
271 DE_FATAL("Unknown shader type");
275 verifyProgram(ctx, sources);
280 void max_combined_block_number_limit (NegativeTestContext& ctx)
282 ctx.beginSection("maxCombinedShaderStorageBlocks: Exceed limits");
284 glu::ProgramSources sources;
286 int combinedSSBlocks = 0;
287 int maxCombinedSSBlocks = 0;
289 combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_VERTEX_SHADER, sources);
290 combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_FRAGMENT_SHADER, sources);
292 if ((ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL)) && (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_EVALUATION)))
294 combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_TESS_CONTROL_SHADER, sources);
295 combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_TESS_EVALUATION_SHADER, sources);
298 if (ctx.isShaderSupported(glu::SHADERTYPE_GEOMETRY))
299 combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_GEOMETRY_SHADER, sources);
301 ctx.glGetIntegerv(GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS, &maxCombinedSSBlocks);
303 ctx.getLog() << tcu::TestLog::Message << "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS: " << maxCombinedSSBlocks << tcu::TestLog::EndMessage;
304 ctx.getLog() << tcu::TestLog::Message << "Combined shader storage blocks: " << combinedSSBlocks << tcu::TestLog::EndMessage;
306 if (combinedSSBlocks > maxCombinedSSBlocks)
307 verifyProgram(ctx, sources);
309 ctx.getLog() << tcu::TestLog::Message << "Test skipped: Combined shader storage blocks < GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS: " << tcu::TestLog::EndMessage;
316 std::vector<FunctionContainer> getNegativeShaderStorageTestFunctions ()
318 const FunctionContainer funcs[] =
320 { block_number_limits, "block_number_limits", "Invalid shader linkage" },
321 { max_combined_block_number_limit, "max_combined_block_number_limit", "Invalid shader linkage" },
324 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
327 } // NegativeTestShared