Support cube map dest target for CopyTextureCHROMIUM extension

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc

 // Copyright (c) 2012 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 <GLES3/gl3.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
+#include "gpu/config/gpu_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 
 namespace {
 
 enum CopyType { TexImage, TexSubImage };
 const CopyType kCopyTypes[] = {
@@ skipping 17 matching lines @@
 
 static const char* kSimpleVertexShaderES3 =
     "#version 300 es\n"
     "in vec2 a_position;\n"
     "out vec2 v_texCoord;\n"
     "void main() {\n"
     "  gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);\n"
     "  v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;\n"
     "}\n";
 
-std::string GetFragmentShaderSource(GLenum format, bool is_es3) {
+std::string GetFragmentShaderSource(GLenum target, GLenum format, bool is_es3) {
   std::string source;
   if (is_es3) {
     source +=
         "#version 300 es\n"
         "#define VARYING in\n"
         "#define FRAGCOLOR frag_color\n"
         "#define TextureLookup texture\n";
   } else {
     source +=
         "#define VARYING varying\n"
-        "#define FRAGCOLOR gl_FragColor\n"
-        "#define TextureLookup texture2D\n";
+        "#define FRAGCOLOR gl_FragColor\n";
+    if (target == GL_TEXTURE_CUBE_MAP) {
+      source += "#define TextureLookup textureCube\n";
+    } else {
+      source += "#define TextureLookup texture2D\n";
+    }
   }
   source += "precision mediump float;\n";
 
   if (gles2::GLES2Util::IsSignedIntegerFormat(format)) {
-    source += std::string("#define SamplerType isampler2D\n");
-    source += std::string("#define TextureType ivec4\n");
-    source += std::string("#define ScaleValue 255.0\n");
+    if (target == GL_TEXTURE_CUBE_MAP) {
+      source += "#define SamplerType isamplerCube\n";
+    } else {
+      source += "#define SamplerType isampler2D\n";
+    }
+    source += "#define TextureType ivec4\n";
+    source += "#define ScaleValue 255.0\n";
   } else if (gles2::GLES2Util::IsUnsignedIntegerFormat(format)) {
-    source += std::string("#define SamplerType usampler2D\n");
-    source += std::string("#define TextureType uvec4\n");
-    source += std::string("#define ScaleValue 255.0\n");
+    if (target == GL_TEXTURE_CUBE_MAP) {
+      source += "#define SamplerType usamplerCube\n";
+    } else {
+      source += "#define SamplerType usampler2D\n";
+    }
+    source += "#define TextureType uvec4\n";
+    source += "#define ScaleValue 255.0\n";
   } else {
-    source += std::string("#define SamplerType sampler2D\n");
-    source += std::string("#define TextureType vec4\n");
-    source += std::string("#define ScaleValue 1.0\n");
+    if (target == GL_TEXTURE_CUBE_MAP) {
+      source += "#define SamplerType samplerCube\n";
+    } else {
+      source += "#define SamplerType sampler2D\n";
+    }
+    source += "#define TextureType vec4\n";
+    source += "#define ScaleValue 1.0\n";
   }
 
   if (is_es3)
     source += "out vec4 frag_color;\n";
 
-  source += std::string(
+  if (target == GL_TEXTURE_CUBE_MAP)
+    source += "uniform highp int u_face;\n";
+
+  source +=
       "uniform mediump SamplerType u_texture;\n"
       "VARYING vec2 v_texCoord;\n"
-      "void main() {\n"
-      "  TextureType color = TextureLookup(u_texture, v_texCoord);\n"
+      "void main() {\n";
+
+  if (target == GL_TEXTURE_CUBE_MAP) {
+    source +=
+        "  vec3 texCube;\n"
+        // Transform [0, 1] to [-1, 1].
+        "  vec2 texCoord = (v_texCoord * 2.0) - 1.0;\n"
+        // Transform 2d tex coord to each face of TEXTURE_CUBE_MAP coord.
+        // TEXTURE_CUBE_MAP_POSITIVE_X
+        "  if (u_face == 34069) {\n"
+        "    texCube = vec3(1.0, -texCoord.y, -texCoord.x);\n"
+        // TEXTURE_CUBE_MAP_NEGATIVE_X
+        "  } else if (u_face == 34070) {\n"
+        "    texCube = vec3(-1.0, -texCoord.y, texCoord.x);\n"
+        // TEXTURE_CUBE_MAP_POSITIVE_Y
+        "  } else if (u_face == 34071) {\n"
+        "    texCube = vec3(texCoord.x, 1.0, texCoord.y);\n"
+        // TEXTURE_CUBE_MAP_NEGATIVE_Y
+        "  } else if (u_face == 34072) {\n"
+        "    texCube = vec3(texCoord.x, -1.0, -texCoord.y);\n"
+        // TEXTURE_CUBE_MAP_POSITIVE_Z
+        "  } else if (u_face == 34073) {\n"
+        "    texCube = vec3(texCoord.x, -texCoord.y, 1.0);\n"
+        // TEXTURE_CUBE_MAP_NEGATIVE_Z
+        "  } else if (u_face == 34074) {\n"
+        "    texCube = vec3(-texCoord.x, -texCoord.y, -1.0);\n"
+        "  }\n"
+        "  TextureType color = TextureLookup(u_texture, texCube);\n";
+  } else {
+    source += "  TextureType color = TextureLookup(u_texture, v_texCoord);\n";
+  }
+
+  source +=
       "  FRAGCOLOR = vec4(color) / ScaleValue;\n"
-      "}\n");
+      "}\n";
   return source;
 }
 
 void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t* color) {
   color[0] = r;
   color[1] = g;
   color[2] = b;
   color[3] = a;
 }
 
@@ skipping 150 matching lines @@
                    GL_UNSIGNED_BYTE, nullptr);
     }
   }
 
   GLuint CreateDrawingTexture(GLenum target, GLsizei width, GLsizei height) {
     GLuint texture = 0;
     glGenTextures(1, &texture);
     glBindTexture(target, texture);
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    CreateBackingForTexture(GL_TEXTURE_2D, width, height);
+    CreateBackingForTexture(target, width, height);
     return texture;
   }
 
   GLuint CreateDrawingFBO(GLenum target, GLuint texture) {
     GLuint framebuffer = 0;
     glGenFramebuffers(1, &framebuffer);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
                            texture, 0);
     return framebuffer;
   }
 
   GLenum ExtractFormatFrom(GLenum internalformat) {
     switch (internalformat) {
       case GL_RGBA8_OES:
         return GL_RGBA;
       case GL_RGB8_OES:
         return GL_RGB;
       case GL_BGRA8_EXT:
         return GL_BGRA_EXT;
       default:
         NOTREACHED();
         return GL_NONE;
     }
   }
 
-  void RunCopyTexture(GLenum target,
+  void RunCopyTexture(GLenum dest_target,
                       CopyType copy_type,
                       FormatType src_format_type,
                       GLint source_level,
                       FormatType dest_format_type,
                       GLint dest_level,
                       bool is_es3) {
     const int src_channel_count = gles2::GLES2Util::ElementsPerGroup(
         src_format_type.format, src_format_type.type);
     uint8_t color[4] = {1u, 63u, 127u, 255u};
     std::unique_ptr<uint8_t[]> pixels(new uint8_t[width_ * height_ * 4]);
     for (int i = 0; i < width_ * height_ * src_channel_count;
          i += src_channel_count)
       for (int j = 0; j < src_channel_count; ++j)
         pixels[i + j] = color[j];
     uint8_t expected_color[4];
     uint8_t mask[4];
     getExpectedColor(src_format_type.internal_format,
                      dest_format_type.internal_format, color, expected_color,
                      mask);
 
+    GLenum source_target = GL_TEXTURE_2D;
     glGenTextures(2, textures_);
-    glBindTexture(target, textures_[0]);
-    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glBindTexture(source_target, textures_[0]);
+    glTexParameteri(source_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(source_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 #if defined(OS_MACOSX)
     // TODO(qiankun.miao@intel.com): Remove this workaround for Mac OSX, once
     // integer texture rendering bug is fixed on Mac OSX: crbug.com/679639.
-    glTexImage2D(target, 0, src_format_type.internal_format,
+    glTexImage2D(source_target, 0, src_format_type.internal_format,
                  width_ << source_level, height_ << source_level, 0,
                  src_format_type.format, src_format_type.type, nullptr);
 #endif
-    glTexImage2D(target, source_level, src_format_type.internal_format, width_,
-                 height_, 0, src_format_type.format, src_format_type.type,
-                 pixels.get());
+    glTexImage2D(source_target, source_level, src_format_type.internal_format,
+                 width_, height_, 0, src_format_type.format,
+                 src_format_type.type, pixels.get());
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
-    glBindTexture(target, textures_[1]);
-    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);
+    GLenum dest_binding_target =
+        gles2::GLES2Util::GLFaceTargetToTextureTarget(dest_target);
+    glBindTexture(dest_binding_target, textures_[1]);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(dest_binding_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     // This hack makes dest texture complete in ES2 and ES3 context
     // respectively. With this, sampling from the dest texture is correct.
     if (is_es3) {
-      glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-      glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, dest_level);
+      glTexParameteri(dest_binding_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      glTexParameteri(dest_binding_target, GL_TEXTURE_BASE_LEVEL, dest_level);
+      // For cube map textures, make the texture is cube complete.
+      if (dest_binding_target == GL_TEXTURE_CUBE_MAP) {
+        for (int i = 0; i < 6; ++i) {
+          GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
+          glTexImage2D(face, dest_level, dest_format_type.internal_format,
+                       width_, height_, 0, dest_format_type.format,
+                       dest_format_type.type, nullptr);
+        }
+      }
 #if defined(OS_MACOSX)
       // TODO(qiankun.miao@intel.com): Remove this workaround for Mac OSX, once
       // framebuffer complete bug is fixed on Mac OSX: crbug.com/678526.
-      glTexImage2D(target, 0, dest_format_type.internal_format,
+      glTexImage2D(dest_target, 0, dest_format_type.internal_format,
                    width_ << dest_level, height_ << dest_level, 0,
                    dest_format_type.format, dest_format_type.type, nullptr);
 #endif
     } else {
-      glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-      glTexImage2D(target, 0, dest_format_type.internal_format,
-                   width_ << dest_level, height_ << dest_level, 0,
-                   dest_format_type.format, dest_format_type.type, nullptr);
-      glGenerateMipmap(target);
+      glTexParameteri(dest_binding_target, GL_TEXTURE_MIN_FILTER,
+                      GL_NEAREST_MIPMAP_NEAREST);
+      // For cube map textures, make the texture is cube complete.

[Zhenyao Mo, 2017/01/27 00:10:17]

nit: remove is.

[qiankun, 2017/01/29 15:39:31]

Done.

+      if (dest_binding_target == GL_TEXTURE_CUBE_MAP) {
+        for (int i = 0; i < 6; ++i) {
+          GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
+          glTexImage2D(face, 0, dest_format_type.internal_format,
+                       width_ << dest_level, height_ << dest_level, 0,
+                       dest_format_type.format, dest_format_type.type, nullptr);
+        }
+      } else {
+        glTexImage2D(dest_target, 0, dest_format_type.internal_format,
+                     width_ << dest_level, height_ << dest_level, 0,
+                     dest_format_type.format, dest_format_type.type, nullptr);
+      }
+      glGenerateMipmap(dest_binding_target);
     }
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
     if (copy_type == TexImage) {
-      glCopyTextureCHROMIUM(textures_[0], source_level, target, textures_[1],
-                            dest_level, dest_format_type.internal_format,
+      glCopyTextureCHROMIUM(textures_[0], source_level, dest_target,
+                            textures_[1], dest_level,
+                            dest_format_type.internal_format,
                             dest_format_type.type, false, false, false);
     } else {
-      glBindTexture(target, textures_[1]);
-      glTexImage2D(target, dest_level, dest_format_type.internal_format, width_,
-                   height_, 0, dest_format_type.format, dest_format_type.type,
-                   nullptr);
+      glBindTexture(dest_binding_target, textures_[1]);
+      glTexImage2D(dest_target, dest_level, dest_format_type.internal_format,
+                   width_, height_, 0, dest_format_type.format,
+                   dest_format_type.type, nullptr);
 
-      glCopySubTextureCHROMIUM(textures_[0], source_level, target, textures_[1],
-                               dest_level, 0, 0, 0, 0, width_, height_, false,
-                               false, false);
+      glCopySubTextureCHROMIUM(textures_[0], source_level, dest_target,
+                               textures_[1], dest_level, 0, 0, 0, 0, width_,
+                               height_, false, false, false);
     }
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
-    // Draw destination texture to a fbo with a texture attachment in RGBA
-    // format.
-    GLuint texture = CreateDrawingTexture(target, width_, height_);
-    GLuint framebuffer = CreateDrawingFBO(target, texture);
+    // Draw destination texture to a fbo with a TEXTURE_2D texture attachment
+    // in RGBA format.
+    GLuint texture = CreateDrawingTexture(GL_TEXTURE_2D, width_, height_);
+    GLuint framebuffer = CreateDrawingFBO(GL_TEXTURE_2D, texture);
     EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
               glCheckFramebufferStatus(GL_FRAMEBUFFER));
     glViewport(0, 0, width_, height_);
 
-    glBindTexture(target, textures_[1]);
-    std::string fragment_shader_source =
-        GetFragmentShaderSource(dest_format_type.internal_format, is_es3);
+    glBindTexture(dest_binding_target, textures_[1]);
+    std::string fragment_shader_source = GetFragmentShaderSource(
+        dest_binding_target, dest_format_type.internal_format, is_es3);
     GLTestHelper::DrawTextureQuad(
-        is_es3 ? kSimpleVertexShaderES3 : kSimpleVertexShaderES2,
-        fragment_shader_source.c_str(), "a_position", "u_texture");
+        dest_target, is_es3 ? kSimpleVertexShaderES3 : kSimpleVertexShaderES2,
+        fragment_shader_source.c_str(), "a_position", "u_texture", "u_face");
     EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
     uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
     EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, width_, height_, tolerance,
                                           expected_color, mask))
+        << " dest_target : " << gles2::GLES2Util::GetStringEnum(dest_target)
         << " src_internal_format: "
         << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
-        << " source_level: " << source_level
-        << " dest_internal_format: "
+        << " source_level: " << source_level << " dest_internal_format: "
         << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format)
         << " dest_level: " << dest_level;
 
     glDeleteTextures(1, &texture);
     glDeleteFramebuffers(1, &framebuffer);
     glDeleteTextures(2, textures_);
   }
 
   GLManager gl_;
   GLuint textures_[2];
   GLsizei width_;
   GLsizei height_;
   GLuint framebuffer_id_;
 };
 
 class GLCopyTextureCHROMIUMES3Test : public GLCopyTextureCHROMIUMTest {
  protected:
   void SetUp() override {
     GLManager::Options options;
     options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
     options.size = gfx::Size(64, 64);
-    gl_.Initialize(options);
+    base::CommandLine command_line(*base::CommandLine::ForCurrentProcess());
+#if defined(OS_MACOSX)
+    // Sampling of seamless integer cube map texture has bug on Intel GEN7 gpus
+    // on Mac OSX, see crbug.com/658930.
+    command_line.AppendSwitchASCII(
+        switches::kGpuDriverBugWorkarounds,
+        base::IntToString(gpu::DISABLE_TEXTURE_CUBE_MAP_SEAMLESS));
+#endif
+    gl_.InitializeWithCommandLine(options, command_line);
 
     width_ = 8;
     height_ = 8;
   }
 
   // If a driver isn't capable of supporting ES3 context, creating
   // ContextGroup will fail. Just skip the test.
   bool ShouldSkipTest() const {
     return (!gl_.decoder() || !gl_.decoder()->GetContextGroup());
   }
@@ skipping 363 matching lines @@
         if (dest_level > 0)
           continue;
 #endif
         RunCopyTexture(GL_TEXTURE_2D, copy_type, src_format_type, source_level,
                        dest_format_type, dest_level, true);
       }
     }
   }
 }
 
+TEST_P(GLCopyTextureCHROMIUMTest, CopyTextureCubeMap) {
+  CopyType copy_type = GetParam();
+
+  GLenum dest_targets[] = {
+      GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z};
+  FormatType src_format_type = {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE};
+  FormatType dest_format_types[] = {
+      {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE}, {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE},
+  };
+  GLint source_level = 0;
+  GLint dest_level = 0;
+
+  for (auto dest_format_type : dest_format_types) {
+    for (auto dest_target : dest_targets) {
+      RunCopyTexture(dest_target, copy_type, src_format_type, source_level,
+                     dest_format_type, dest_level, false);
+    }
+  }
+}
+
+TEST_P(GLCopyTextureCHROMIUMES3Test, CopyTextureCubeMap) {
+  if (ShouldSkipTest())
+    return;
+  CopyType copy_type = GetParam();
+
+  GLenum dest_targets[] = {
+      GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z};
+  FormatType src_format_type = {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE};
+  FormatType dest_format_types[] = {
+      {GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE},
+      {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},
+  };
+  GLint source_level = 0;
+  GLint dest_level = 0;
+
+  for (auto dest_format_type : dest_format_types) {
+    for (auto dest_target : dest_targets) {
+      RunCopyTexture(dest_target, copy_type, src_format_type, source_level,
+                     dest_format_type, dest_level, true);
+    }
+  }
+}
+
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
   uint8_t pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
                            255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
 
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
@@ skipping 644 matching lines @@
         }
       }
 
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu