diff options
Diffstat (limited to 'chromium/gpu/command_buffer/service/shader_translator_unittest.cc')
| -rw-r--r-- | chromium/gpu/command_buffer/service/shader_translator_unittest.cc | 147 |
1 files changed, 127 insertions, 20 deletions
diff --git a/chromium/gpu/command_buffer/service/shader_translator_unittest.cc b/chromium/gpu/command_buffer/service/shader_translator_unittest.cc index 5f6173818f9..0c60b44c5a6 100644 --- a/chromium/gpu/command_buffer/service/shader_translator_unittest.cc +++ b/chromium/gpu/command_buffer/service/shader_translator_unittest.cc @@ -6,6 +6,7 @@ #include "gpu/command_buffer/service/shader_translator.h" #include "testing/gtest/include/gtest/gtest.h" +#include "ui/gl/gl_version_info.h" namespace gpu { namespace gles2 { @@ -13,6 +14,9 @@ namespace gles2 { class ShaderTranslatorTest : public testing::Test { public: ShaderTranslatorTest() { + shader_output_language_ = + ShaderTranslator::GetShaderOutputLanguageForContext( + gfx::GLVersionInfo("2.0", "", "")); } ~ShaderTranslatorTest() override {} @@ -27,14 +31,12 @@ class ShaderTranslatorTest : public testing::Test { vertex_translator_ = new ShaderTranslator(); fragment_translator_ = new ShaderTranslator(); - ASSERT_TRUE(vertex_translator_->Init( - GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, - ShaderTranslatorInterface::kGlsl, - SH_EMULATE_BUILT_IN_FUNCTIONS)); - ASSERT_TRUE(fragment_translator_->Init( - GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources, - ShaderTranslatorInterface::kGlsl, - static_cast<ShCompileOptions>(0))); + ASSERT_TRUE(vertex_translator_->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, + &resources, shader_output_language_, + SH_EMULATE_BUILT_IN_FUNCTIONS)); + ASSERT_TRUE(fragment_translator_->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, + &resources, shader_output_language_, + static_cast<ShCompileOptions>(0))); } void TearDown() override { vertex_translator_ = NULL; @@ -43,6 +45,7 @@ class ShaderTranslatorTest : public testing::Test { scoped_refptr<ShaderTranslator> vertex_translator_; scoped_refptr<ShaderTranslator> fragment_translator_; + ShShaderOutput shader_output_language_; }; TEST_F(ShaderTranslatorTest, ValidVertexShader) { @@ -290,19 +293,16 @@ TEST_F(ShaderTranslatorTest, OptionsString) { ShBuiltInResources resources; ShInitBuiltInResources(&resources); - ASSERT_TRUE(translator_1->Init( - GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, - ShaderTranslatorInterface::kGlsl, - SH_EMULATE_BUILT_IN_FUNCTIONS)); - ASSERT_TRUE(translator_2->Init( - GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources, - ShaderTranslatorInterface::kGlsl, - static_cast<ShCompileOptions>(0))); + ASSERT_TRUE(translator_1->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, + SH_GLSL_150_CORE_OUTPUT, + SH_EMULATE_BUILT_IN_FUNCTIONS)); + ASSERT_TRUE(translator_2->Init(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources, + SH_GLSL_150_CORE_OUTPUT, + static_cast<ShCompileOptions>(0))); resources.EXT_draw_buffers = 1; - ASSERT_TRUE(translator_3->Init( - GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, - ShaderTranslatorInterface::kGlsl, - SH_EMULATE_BUILT_IN_FUNCTIONS)); + ASSERT_TRUE(translator_3->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, + SH_GLSL_150_CORE_OUTPUT, + SH_EMULATE_BUILT_IN_FUNCTIONS)); std::string options_1( translator_1->GetStringForOptionsThatWouldAffectCompilation()); @@ -319,6 +319,113 @@ TEST_F(ShaderTranslatorTest, OptionsString) { EXPECT_NE(options_3, options_4); } +class ShaderTranslatorOutputVersionTest + : public testing::TestWithParam<testing::tuple<const char*, const char*>> { +}; + +TEST_P(ShaderTranslatorOutputVersionTest, HasCorrectOutputGLSLVersion) { + // Test that translating to a shader targeting certain OpenGL context version + // (version string in test param tuple index 0) produces a GLSL shader that + // contains correct version string for that context (version directive + // in test param tuple index 1). + + const char* kShader = + "attribute vec4 vPosition;\n" + "void main() {\n" + " gl_Position = vPosition;\n" + "}"; + + gfx::GLVersionInfo output_context_version(testing::get<0>(GetParam()), "", + ""); + + scoped_refptr<ShaderTranslator> translator = new ShaderTranslator(); + ShBuiltInResources resources; + ShInitBuiltInResources(&resources); + ShCompileOptions compile_options = SH_OBJECT_CODE; + ShShaderOutput shader_output_language = + ShaderTranslator::GetShaderOutputLanguageForContext( + output_context_version); + ASSERT_TRUE(translator->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources, + shader_output_language, compile_options)); + + std::string translated_source; + int shader_version; + EXPECT_TRUE(translator->Translate(kShader, nullptr, &translated_source, + &shader_version, nullptr, nullptr, nullptr, + nullptr)); + + std::string expected_version_directive = testing::get<1>(GetParam()); + if (expected_version_directive.empty()) { + EXPECT_TRUE(translated_source.find("#version") == std::string::npos) + << "Translation was:\n" << translated_source; + } else { + EXPECT_TRUE(translated_source.find(expected_version_directive) != + std::string::npos) + << "Translation was:\n" << translated_source; + } +} + +// For some compilers, using make_tuple("a", "bb") would end up +// instantiating make_tuple<char[1], char[2]>. This does not work. +namespace { +testing::tuple<const char*, const char*> make_gl_glsl_tuple( + const char* gl_version, + const char* glsl_version_directive) { + return testing::make_tuple(gl_version, glsl_version_directive); +} +} + +// Test data for the above test. OpenGL specifications specify a +// certain version of GLSL to be guaranteed to be supported. Test +// that ShaderTranslator produces a GLSL shader with the exact +// specified GLSL version for each known OpenGL version. +INSTANTIATE_TEST_CASE_P( + KnownOpenGLContexts, + ShaderTranslatorOutputVersionTest, + testing::Values(make_gl_glsl_tuple("4.5", "#version 450\n"), + make_gl_glsl_tuple("4.4", "#version 440\n"), + make_gl_glsl_tuple("4.3", "#version 430\n"), + make_gl_glsl_tuple("4.2", "#version 420\n"), + make_gl_glsl_tuple("4.1", "#version 410\n"), + make_gl_glsl_tuple("4.0", "#version 400\n"), + make_gl_glsl_tuple("3.3", "#version 330\n"), + make_gl_glsl_tuple("3.2", "#version 150\n"), + make_gl_glsl_tuple("3.1", "#version 140\n"), + make_gl_glsl_tuple("3.0", "#version 130\n"))); + +// Test data for the above test. Check that early OpenGL contexts get +// GLSL compatibility profile shader, e.g. shader has no #version +// directive. Also check that future version 3.3+ OpenGL contexts get +// similar shader. We do not expect that future 3.3+ specs contain +// the "all eariler GLSL versions" clause, since 3.3 did not contain +// it either. +INSTANTIATE_TEST_CASE_P(OldOrUnknownOpenGLContexts, + ShaderTranslatorOutputVersionTest, + testing::Values(make_gl_glsl_tuple("3.4", ""), + make_gl_glsl_tuple("2.0", ""))); + +// Test data for the above test. Cases for the future OpenGL versions. The +// code assumes that the future OpenGL specs specify the clause that all +// earlier GLSL versions are supported. We select the highest GLSL +// version known at the time of writing. +INSTANTIATE_TEST_CASE_P( + BackwardsCompatibleFutureOpenGLContexts, + ShaderTranslatorOutputVersionTest, + testing::Values(make_gl_glsl_tuple("5.0", "#version 450\n"), + make_gl_glsl_tuple("4.6", "#version 450\n"))); + +// Test data for the above test. Check that for the OpenGL ES output +// contexts, the shader is such that GLSL 1.0 is used. The translator +// selects GLSL 1.0 by not output any version at the moment, though we +// do not know if that would be correct for the future OpenGL ES specs. +INSTANTIATE_TEST_CASE_P(OpenGLESContexts, + ShaderTranslatorOutputVersionTest, + testing::Values(make_gl_glsl_tuple("opengl es 2.0", ""), + make_gl_glsl_tuple("opengl es 3.0", ""), + make_gl_glsl_tuple("opengl es 3.1", ""), + make_gl_glsl_tuple("opengl es 3.2", + ""))); + } // namespace gles2 } // namespace gpu |