Index: gpu/command_buffer/tests/gl_apply_screen_space_antialiasing_CHROMIUM_unittest.cc |
diff --git a/gpu/command_buffer/tests/gl_apply_screen_space_antialiasing_CHROMIUM_unittest.cc b/gpu/command_buffer/tests/gl_apply_screen_space_antialiasing_CHROMIUM_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..7764e6d9ea334396ac35ddca88210df619418254 |
--- /dev/null |
+++ b/gpu/command_buffer/tests/gl_apply_screen_space_antialiasing_CHROMIUM_unittest.cc |
@@ -0,0 +1,427 @@ |
+// Copyright (c) 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#ifndef GL_GLEXT_PROTOTYPES |
+#define GL_GLEXT_PROTOTYPES |
+#endif |
+ |
+#include <GLES2/gl2.h> |
+#include <GLES2/gl2ext.h> |
+#include <GLES2/gl2extchromium.h> |
+#include <stddef.h> |
+#include <stdint.h> |
+ |
+#include "base/command_line.h" |
+#include "gpu/command_buffer/tests/gl_manager.h" |
+#include "gpu/command_buffer/tests/gl_test_utils.h" |
+#include "testing/gmock/include/gmock/gmock.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "ui/gl/gl_switches.h" |
+ |
+namespace gpu { |
+ |
+// A collection of tests that exercise the GL_CHROMIUM_copy_texture extension. |
+class GLApplyScreenSpaceAntialiasingCHROMIUMTest : public testing::Test { |
+ protected: |
+ void CreateAndBindDestinationTextureAndFBO(GLenum target) { |
+ glGenTextures(1, &textures_); |
+ glBindTexture(target, textures_); |
+ |
+ // Some drivers (NVidia/SGX) require texture settings to be a certain way or |
+ // they won't report FRAMEBUFFER_COMPLETE. |
+ glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
+ glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
+ glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
+ glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
+ |
+ glGenFramebuffers(1, &framebuffer_id_); |
+ glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_); |
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, |
+ textures_, 0); |
+ } |
+ |
+ void SetUp() override { |
+ base::CommandLine command_line(base::CommandLine::NO_PROGRAM); |
+ GLManager::Options options; |
+ gl_.InitializeWithCommandLine(options, command_line); |
+ |
+ available_ = |
+ GLTestHelper::HasExtension("GL_CHROMIUM_screen_space_antialiasing"); |
+ if (!available_) { |
+ LOG(INFO) << "GL_CHROMIUM_screen_space_antialiasing not supported. " |
+ "Skipping test..."; |
+ return; |
+ } |
+ |
+ CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D); |
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
+ nullptr); |
+ EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), |
+ glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
+ |
+ glClearColor(0, 1, 0, 1); |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ if (glGetError() == GL_NO_ERROR) |
+ return; |
+ |
+ // For example, linux NVidia fails with this log. |
+ // ApplyFramebufferAttachmentCMAAINTEL: shader compilation failed: |
+ // GL_FRAGMENT_SHADER shader compilation failed: 0(98) : error C3013: |
+ // input/output layout qualifiers supported above GL version 130 |
+ available_ = false; |
+ LOG(ERROR) << "GL_CHROMIUM_screen_space_antialiasing maybe not supported " |
+ "in non-Intel GPU."; |
+ } |
+ |
+ void TearDown() override { |
+ glDeleteTextures(1, &textures_); |
+ glDeleteFramebuffers(1, &framebuffer_id_); |
+ gl_.Destroy(); |
+ } |
+ |
+ GLManager gl_; |
+ GLuint textures_ = 0; |
+ GLuint framebuffer_id_ = 0; |
+ bool available_ = false; |
+}; |
+ |
+// Test to ensure that the basic functionality of the extension works. |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, Basic) { |
+ if (!available_) |
+ return; |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ // Check the FB is still bound. |
+ GLint value = 0; |
+ glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value); |
+ GLuint fb_id = value; |
+ EXPECT_EQ(framebuffer_id_, fb_id); |
+ |
+ // Check that FB is complete. |
+ EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), |
+ glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
+ |
+ uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u}; |
+ GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+} |
+ |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, DefaultFBO) { |
+ if (!available_) |
+ return; |
+ |
+ glBindFramebuffer(GL_FRAMEBUFFER, 0); |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError()); |
+} |
+ |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, InternalFormat) { |
+ if (!available_) |
+ return; |
+ |
+ GLint formats[] = {GL_RGB, GL_RGBA}; |
+ for (size_t index = 0; index < arraysize(formats); index++) { |
+ glTexImage2D(GL_TEXTURE_2D, 0, formats[index], 1, 1, 0, formats[index], |
+ GL_UNSIGNED_BYTE, nullptr); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
+ textures_, 0); |
+ |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()) << "index:" |
+ << index; |
+ |
+ uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u}; |
+ GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ } |
+} |
+ |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, InternalFormatNotSupported) { |
+ if (!available_) |
+ return; |
+ |
+ // Check unsupported format reports error. |
+ GLint unsupported_formats[] = {GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA}; |
+ for (size_t index = 0; index < arraysize(unsupported_formats); index++) { |
+ glTexImage2D(GL_TEXTURE_2D, 0, unsupported_formats[index], 1, 1, 0, |
+ unsupported_formats[index], GL_UNSIGNED_BYTE, nullptr); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, |
+ textures_, 0); |
+ |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_INVALID_FRAMEBUFFER_OPERATION), |
+ glGetError()) |
+ << "index:" << index; |
+ } |
+} |
+ |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, ImmutableTexture) { |
+ if (!available_) |
+ return; |
+ |
+ if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) { |
+ LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test..."; |
+ return; |
+ } |
+ GLenum internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT}; |
+ for (auto internal_format : internal_formats) { |
+ glDeleteTextures(1, &textures_); |
+ glDeleteFramebuffers(1, &framebuffer_id_); |
+ CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D); |
+ glTexStorage2DEXT(GL_TEXTURE_2D, 1, internal_format, 1, 1); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), |
+ glCheckFramebufferStatus(GL_FRAMEBUFFER)); |
+ |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u}; |
+ GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ } |
+} |
+ |
+// Similar to webgl conformance test 'testAntialias(true)' in |
+// context-attributes-alpha-depth-stencil-antialias.html |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, AntiAliasing) { |
+ if (!available_) |
+ return; |
+ |
+ // Fill colors in the FBO as follows |
+ // +-----+ |
+ // |R|R| | |
+ // +-----+ |
+ // |R| | | |
+ // +-----+ |
+ // | | | | |
+ // +-+-+-+ |
+ const int length = 3; |
+ uint8_t rgba_pixels[4 * length * length] = { |
+ 255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u, 0u, 0u, 0u, 0u, |
+ 255u, 0u, 0u, 255u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, |
+ 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, |
+ }; |
+ glBindTexture(GL_TEXTURE_2D, textures_); |
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, length, length, 0, GL_RGBA, |
+ GL_UNSIGNED_BYTE, rgba_pixels); |
+ |
+ uint8_t transparent[4] = {0u, 0u, 0u, 0u}; |
+ uint8_t red[4] = {255u, 0u, 0u, 255u}; |
+ GLTestHelper::CheckPixels(0, 0, 1, 1, 0, red); |
+ GLTestHelper::CheckPixels(0, 1, 1, 1, 0, red); |
+ GLTestHelper::CheckPixels(0, 2, 1, 1, 0, transparent); |
+ GLTestHelper::CheckPixels(1, 0, 1, 1, 0, red); |
+ GLTestHelper::CheckPixels(1, 1, 1, 1, 0, transparent); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ GLTestHelper::CheckPixels(0, 0, 1, 1, 0, red); |
+ GLTestHelper::CheckPixels(2, 2, 1, 1, 0, transparent); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ // Check if middle pixel is anti-aliased. |
+ uint8_t pixels[4] = {0u}; |
+ glReadPixels(1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &pixels); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ EXPECT_NE(transparent, pixels); |
+ EXPECT_NE(red, pixels); |
+ EXPECT_TRUE(pixels[0] > transparent[0] && pixels[0] < red[0]); |
+ EXPECT_EQ(0u, pixels[1]); |
+ EXPECT_EQ(0u, pixels[2]); |
+ EXPECT_TRUE(pixels[3] > transparent[3] && pixels[3] < red[3]); |
+} |
+ |
+namespace { |
+ |
+void glEnableDisable(GLint param, GLboolean value) { |
+ if (value) |
+ glEnable(param); |
+ else |
+ glDisable(param); |
+} |
+ |
+} // unnamed namespace |
+ |
+// Validate that some basic GL state is not touched upon execution of |
+// the extension. |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, BasicStatePreservation) { |
+ if (!available_) |
+ return; |
+ |
+ GLboolean reference_settings[2] = {GL_TRUE, GL_FALSE}; |
+ for (int x = 0; x < 2; ++x) { |
+ GLboolean setting = reference_settings[x]; |
+ glEnableDisable(GL_DEPTH_TEST, setting); |
+ glEnableDisable(GL_SCISSOR_TEST, setting); |
+ glEnableDisable(GL_STENCIL_TEST, setting); |
+ glEnableDisable(GL_CULL_FACE, setting); |
+ glEnableDisable(GL_BLEND, setting); |
+ glColorMask(setting, setting, setting, setting); |
+ glDepthMask(setting); |
+ |
+ glActiveTexture(GL_TEXTURE1 + x); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ EXPECT_EQ(setting, glIsEnabled(GL_DEPTH_TEST)); |
+ EXPECT_EQ(setting, glIsEnabled(GL_SCISSOR_TEST)); |
+ EXPECT_EQ(setting, glIsEnabled(GL_STENCIL_TEST)); |
+ EXPECT_EQ(setting, glIsEnabled(GL_CULL_FACE)); |
+ EXPECT_EQ(setting, glIsEnabled(GL_BLEND)); |
+ |
+ GLboolean bool_array[4] = {GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE}; |
+ glGetBooleanv(GL_DEPTH_WRITEMASK, bool_array); |
+ EXPECT_EQ(setting, bool_array[0]); |
+ |
+ bool_array[0] = GL_FALSE; |
+ glGetBooleanv(GL_COLOR_WRITEMASK, bool_array); |
+ EXPECT_EQ(setting, bool_array[0]); |
+ EXPECT_EQ(setting, bool_array[1]); |
+ EXPECT_EQ(setting, bool_array[2]); |
+ EXPECT_EQ(setting, bool_array[3]); |
+ |
+ GLint active_texture = 0; |
+ glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); |
+ EXPECT_EQ(GL_TEXTURE1 + x, active_texture); |
+ } |
+ |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+}; |
+ |
+// Verify that invocation of the extension does not modify the bound |
+// texture state. |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, TextureStatePreserved) { |
+ if (!available_) |
+ return; |
+ |
+ GLuint texture_ids[2]; |
+ glGenTextures(2, texture_ids); |
+ |
+ glActiveTexture(GL_TEXTURE0); |
+ glBindTexture(GL_TEXTURE_2D, texture_ids[0]); |
+ |
+ glActiveTexture(GL_TEXTURE1); |
+ glBindTexture(GL_TEXTURE_2D, texture_ids[1]); |
+ |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ GLint active_texture = 0; |
+ glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); |
+ EXPECT_EQ(GL_TEXTURE1, active_texture); |
+ |
+ GLint bound_texture = 0; |
+ glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); |
+ EXPECT_EQ(texture_ids[1], static_cast<GLuint>(bound_texture)); |
+ glBindTexture(GL_TEXTURE_2D, 0); |
+ |
+ bound_texture = 0; |
+ glActiveTexture(GL_TEXTURE0); |
+ glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); |
+ EXPECT_EQ(texture_ids[0], static_cast<GLuint>(bound_texture)); |
+ glBindTexture(GL_TEXTURE_2D, 0); |
+ |
+ glDeleteTextures(2, texture_ids); |
+ |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+} |
+ |
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, ProgramStatePreservation) { |
+ if (!available_) |
+ return; |
+ |
+ // unbind the one created in setup. |
+ glBindFramebuffer(GL_FRAMEBUFFER, 0); |
+ glBindTexture(GL_TEXTURE_2D, 0); |
+ |
+ GLManager gl2; |
+ GLManager::Options options; |
+ options.size = gfx::Size(16, 16); |
+ options.share_group_manager = &gl_; |
+ gl2.Initialize(options); |
+ gl_.MakeCurrent(); |
+ |
+ static const char* v_shader_str = |
+ "attribute vec4 g_Position;\n" |
+ "void main()\n" |
+ "{\n" |
+ " gl_Position = g_Position;\n" |
+ "}\n"; |
+ static const char* f_shader_str = |
+ "precision mediump float;\n" |
+ "void main()\n" |
+ "{\n" |
+ " gl_FragColor = vec4(0,1,0,1);\n" |
+ "}\n"; |
+ |
+ GLuint program = GLTestHelper::LoadProgram(v_shader_str, f_shader_str); |
+ glUseProgram(program); |
+ GLuint position_loc = glGetAttribLocation(program, "g_Position"); |
+ glFlush(); |
+ |
+ // Delete program from other context. |
+ gl2.MakeCurrent(); |
+ glDeleteProgram(program); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ glFlush(); |
+ |
+ // Program should still be usable on this context. |
+ gl_.MakeCurrent(); |
+ |
+ GLTestHelper::SetupUnitQuad(position_loc); |
+ |
+ // test using program before |
+ uint8_t expected[] = { |
+ 0, 255, 0, 255, |
+ }; |
+ uint8_t zero[] = { |
+ 0, 0, 0, 0, |
+ }; |
+ glClearColor(0, 0, 0, 0); |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); |
+ glDrawArrays(GL_TRIANGLES, 0, 6); |
+ EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); |
+ |
+ // Call copyTextureCHROMIUM |
+ uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u}; |
+ glBindTexture(GL_TEXTURE_2D, textures_); |
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
+ pixels); |
+ glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_); |
+ glApplyScreenSpaceAntialiasingCHROMIUM(); |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ // test using program after |
+ glClear(GL_COLOR_BUFFER_BIT); |
+ EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); |
+ glDrawArrays(GL_TRIANGLES, 0, 6); |
+ EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); |
+ |
+ EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()); |
+ |
+ gl2.MakeCurrent(); |
+ gl2.Destroy(); |
+ gl_.MakeCurrent(); |
+} |
+ |
+} // namespace gpu |