/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 3.1 Module
* -------------------------------------------------
*
* Copyright 2016 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 Negative Shader Storage Tests
*//*--------------------------------------------------------------------*/
#include "es31fNegativeShaderStorageTests.hpp"
#include "gluShaderProgram.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace NegativeTestShared
{
namespace
{
void verifyProgram(NegativeTestContext& ctx, glu::ProgramSources sources)
{
tcu::TestLog& log = ctx.getLog();
const glu::ShaderProgram program (ctx.getRenderContext(), sources);
bool testFailed = false;
log << program;
testFailed = program.getProgramInfo().linkOk;
if (testFailed)
{
const char* const message("Program was not expected to link.");
log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
ctx.fail(message);
}
}
const char* getShaderExtensionDeclaration (glw::GLenum glShaderType)
{
switch (glShaderType)
{
case GL_TESS_CONTROL_SHADER:
case GL_TESS_EVALUATION_SHADER: return "#extension GL_EXT_tessellation_shader : require\n";
case GL_GEOMETRY_SHADER: return "#extension GL_EXT_geometry_shader : require\n";
default:
return "";
}
}
glu::ShaderType getGLUShaderType (glw::GLenum glShaderType)
{
switch (glShaderType)
{
case GL_VERTEX_SHADER: return glu::SHADERTYPE_VERTEX;
case GL_FRAGMENT_SHADER: return glu::SHADERTYPE_FRAGMENT;
case GL_TESS_CONTROL_SHADER: return glu::SHADERTYPE_TESSELLATION_CONTROL;
case GL_TESS_EVALUATION_SHADER: return glu::SHADERTYPE_TESSELLATION_EVALUATION;
case GL_GEOMETRY_SHADER: return glu::SHADERTYPE_GEOMETRY;
case GL_COMPUTE_SHADER: return glu::SHADERTYPE_COMPUTE;
default:
DE_FATAL("Unknown shader type");
return glu::SHADERTYPE_LAST;
}
}
glw::GLenum getMaxSSBlockSizeEnum (glw::GLenum glShaderType)
{
switch (glShaderType)
{
case GL_VERTEX_SHADER: return GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS;
case GL_FRAGMENT_SHADER: return GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS;
case GL_TESS_CONTROL_SHADER: return GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS;
case GL_TESS_EVALUATION_SHADER: return GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS;
case GL_GEOMETRY_SHADER: return GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS;
case GL_COMPUTE_SHADER: return GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS;
default:
DE_FATAL("Unknown shader type");
return -1;
}
}
int getMaxSSBlockSize (NegativeTestContext& ctx, glw::GLenum glShaderType)
{
int maxSSBlocks = 0;
ctx.glGetIntegerv(getMaxSSBlockSizeEnum(glShaderType), &maxSSBlocks);
return maxSSBlocks;
}
std::string genBlockSource (NegativeTestContext& ctx, deInt64 numSSBlocks, glw::GLenum shaderType)
{
const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
std::ostringstream source;
source << glu::getGLSLVersionDeclaration(version) << "\n"
<< ((isES32) ? "" : getShaderExtensionDeclaration(shaderType));
switch (shaderType)
{
case GL_VERTEX_SHADER:
case GL_FRAGMENT_SHADER:
break;
case GL_COMPUTE_SHADER:
source << "layout (local_size_x = 1) in;\n";
break;
case GL_GEOMETRY_SHADER:
source << "layout(points) in;\n"
<< "layout(line_strip, max_vertices = 3) out;\n";
break;
case GL_TESS_CONTROL_SHADER:
source << "layout(vertices = 10) out;\n";
break;
case GL_TESS_EVALUATION_SHADER:
source << "layout(triangles) in;\n";
break;
default:
DE_FATAL("Unknown shader type");
break;
}
source << "\n"
<< "layout(std430, binding = 0) buffer Block {\n"
<< " int value;\n"
<< "} sb_in[" << numSSBlocks << "];\n"
<< "void main(void) { sb_in[0].value = 1; }\n";
return source.str();
}
std::string genCommonSource (NegativeTestContext& ctx, glw::GLenum shaderType)
{
const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
std::ostringstream source;
source << glu::getGLSLVersionDeclaration(version) << "\n"
<< ((isES32) ? "" : getShaderExtensionDeclaration(shaderType));
switch (shaderType)
{
case GL_TESS_CONTROL_SHADER:
source << "layout(vertices = 3) out;\n"
<< "void main() {}\n";
break;
case GL_TESS_EVALUATION_SHADER:
source << "layout(triangles, equal_spacing, cw) in;\n"
<< "void main() {}\n";
break;
default:
source << "void main() {}\n";
break;
}
return source.str();
}
int genMaxSSBlocksSource (NegativeTestContext& ctx, glw::GLenum glShaderType, glu::ProgramSources& sources)
{
int maxSSBlocks = getMaxSSBlockSize(ctx, glShaderType);
const std::string shaderSrc = genBlockSource(ctx, (maxSSBlocks), glShaderType);
sources.sources[getGLUShaderType(glShaderType)].push_back(shaderSrc);
return maxSSBlocks;
}
void block_number_limits (NegativeTestContext& ctx)
{
const glw::GLenum glShaderTypes[] =
{
GL_VERTEX_SHADER,
GL_FRAGMENT_SHADER,
GL_TESS_CONTROL_SHADER,
GL_TESS_EVALUATION_SHADER,
GL_GEOMETRY_SHADER,
GL_COMPUTE_SHADER,
};
const std::string vertSource = genCommonSource(ctx, GL_VERTEX_SHADER);
const std::string fragSource = genCommonSource(ctx, GL_FRAGMENT_SHADER);
const std::string tessControlSource = genCommonSource(ctx, GL_TESS_CONTROL_SHADER);
const std::string tessEvalSource = genCommonSource(ctx, GL_TESS_EVALUATION_SHADER);
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(glShaderTypes); ndx++)
{
ctx.beginSection("maxShaderStorageBlocks: Exceed limits");
if (!ctx.isShaderSupported(static_cast<glu::ShaderType>(getGLUShaderType(glShaderTypes[ndx]))))
{
ctx.endSection();
continue;
}
int maxSSBlocks = getMaxSSBlockSize(ctx, glShaderTypes[ndx]);
std::string source = genBlockSource(ctx, maxSSBlocks+1, glShaderTypes[ndx]);
glu::ProgramSources sources;
if (maxSSBlocks == 0)
{
ctx.endSection();
continue;
}
switch (glShaderTypes[ndx])
{
case GL_VERTEX_SHADER:
sources << glu::VertexSource(source)
<< glu::FragmentSource(fragSource);
break;
case GL_FRAGMENT_SHADER:
sources << glu::VertexSource(vertSource)
<< glu::FragmentSource(source);
break;
case GL_TESS_CONTROL_SHADER:
sources << glu::VertexSource(vertSource)
<< glu::FragmentSource(fragSource)
<< glu::TessellationControlSource(source)
<< glu::TessellationEvaluationSource(tessEvalSource);
break;
case GL_TESS_EVALUATION_SHADER:
sources << glu::VertexSource(vertSource)
<< glu::FragmentSource(fragSource)
<< glu::TessellationControlSource(tessControlSource)
<< glu::TessellationEvaluationSource(source);
break;
case GL_GEOMETRY_SHADER:
sources << glu::VertexSource(vertSource)
<< glu::FragmentSource(fragSource)
<< glu::GeometrySource(source);
break;
case GL_COMPUTE_SHADER:
sources << glu::ComputeSource(source);
break;
default:
DE_FATAL("Unknown shader type");
break;
}
verifyProgram(ctx, sources);
ctx.endSection();
}
}
void max_combined_block_number_limit (NegativeTestContext& ctx)
{
ctx.beginSection("maxCombinedShaderStorageBlocks: Exceed limits");
glu::ProgramSources sources;
int combinedSSBlocks = 0;
int maxCombinedSSBlocks = 0;
combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_VERTEX_SHADER, sources);
combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_FRAGMENT_SHADER, sources);
if ((ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL)) && (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_EVALUATION)))
{
combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_TESS_CONTROL_SHADER, sources);
combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_TESS_EVALUATION_SHADER, sources);
}
if (ctx.isShaderSupported(glu::SHADERTYPE_GEOMETRY))
combinedSSBlocks += genMaxSSBlocksSource(ctx, GL_GEOMETRY_SHADER, sources);
ctx.glGetIntegerv(GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS, &maxCombinedSSBlocks);
ctx.getLog() << tcu::TestLog::Message << "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS: " << maxCombinedSSBlocks << tcu::TestLog::EndMessage;
ctx.getLog() << tcu::TestLog::Message << "Combined shader storage blocks: " << combinedSSBlocks << tcu::TestLog::EndMessage;
if (combinedSSBlocks > maxCombinedSSBlocks)
verifyProgram(ctx, sources);
else
ctx.getLog() << tcu::TestLog::Message << "Test skipped: Combined shader storage blocks < GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS: " << tcu::TestLog::EndMessage;
ctx.endSection();
}
} // anonymous
std::vector<FunctionContainer> getNegativeShaderStorageTestFunctions ()
{
const FunctionContainer funcs[] =
{
{ block_number_limits, "block_number_limits", "Invalid shader linkage" },
{ max_combined_block_number_limit, "max_combined_block_number_limit", "Invalid shader linkage" },
};
return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
}
} // NegativeTestShared
} // Functional
} // gles31
} // deqp