Added minimal support to command buffer for GL_ARB_texture_rectangle

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2011 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.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "base/bits.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
 static GLsizei ComputeMipMapCount(
     GLsizei width, GLsizei height, GLsizei depth) {
   return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
 }
 
 static size_t GLTargetToFaceIndex(GLenum target) {
   switch (target) {
     case GL_TEXTURE_2D:
     case GL_TEXTURE_EXTERNAL_OES:
+    case GL_TEXTURE_RECTANGLE_ARB:
       return 0;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       return 0;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       return 1;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       return 2;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       return 3;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
@@ skipping 52 matching lines @@
     glDeleteTextures(arraysize(ids), ids);
   }
 }
 
 bool TextureManager::TextureInfo::CanRender(
     const FeatureInfo* feature_info) const {
   if (target_ == 0) {
     return false;
   }
   bool needs_mips = NeedsMips();
-  if (npot() && !feature_info->feature_flags().npot_ok) {
+  if ((npot() && !feature_info->feature_flags().npot_ok) ||
+      (target_ == GL_TEXTURE_RECTANGLE_ARB)) {
     return !needs_mips &&
            wrap_s_ == GL_CLAMP_TO_EDGE &&
            wrap_t_ == GL_CLAMP_TO_EDGE;
   }
   if (needs_mips) {
     if (target_ == GL_TEXTURE_2D) {
       return texture_complete();
     } else {
       return texture_complete() && cube_complete();
     }
@@ skipping 38 matching lines @@
 
 void TextureManager::TextureInfo::SetTarget(GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   level_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     level_infos_[ii].resize(max_levels);
   }
 
-  if (target == GL_TEXTURE_EXTERNAL_OES) {
+  if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 }
 
 bool TextureManager::TextureInfo::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       level_infos_.empty() ||
-      target_ == GL_TEXTURE_EXTERNAL_OES) {
+      target_ == GL_TEXTURE_EXTERNAL_OES ||
+      target_ == GL_TEXTURE_RECTANGLE_ARB) {
     return false;
   }
   const TextureInfo::LevelInfo& first = level_infos_[0][0];
   // TODO(gman): Check internal_format, format and type.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
     if ((info.target == 0) ||
         (info.width != first.width) ||
         (info.height != first.height) ||
         (info.depth != 1) ||
@@ skipping 145 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::SetParameter(
     const FeatureInfo* feature_info, GLenum pname, GLint param) {
   DCHECK(feature_info);
 
-  if (target_ == GL_TEXTURE_EXTERNAL_OES) {
+  if (target_ == GL_TEXTURE_EXTERNAL_OES ||
+      target_ == GL_TEXTURE_RECTANGLE_ARB) {
     if (pname == GL_TEXTURE_MIN_FILTER &&
         (param != GL_NEAREST && param != GL_LINEAR))
       return false;
     if ((pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T) &&
         param != GL_CLAMP_TO_EDGE)
       return false;
   }
 
   switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
@@ skipping 192 matching lines @@
       max_levels_(ComputeMipMapCount(max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
       max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       black_2d_texture_id_(0),
-      black_cube_texture_id_(0) {
+      black_cube_texture_id_(0),
+      black_oes_external_texture_id_(0),
+      black_arb_texture_rectangle_id_(0) {
 }
 
 bool TextureManager::Initialize(const FeatureInfo* feature_info) {
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
 
-  // Make default textures and texture for replacing non-renderable textures.
-  GLuint ids[4];
-  glGenTextures(arraysize(ids), ids);
-  static uint8 black[] = {0, 0, 0, 255};
-  for (int ii = 0; ii < 2; ++ii) {
-    glBindTexture(GL_TEXTURE_2D, ids[ii]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, black);
-    glBindTexture(GL_TEXTURE_CUBE_MAP, ids[2 + ii]);
-    for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
-      glTexImage2D(GLES2Util::IndexToGLFaceTarget(ii), 0, GL_RGBA, 1, 1, 0,
-                   GL_RGBA, GL_UNSIGNED_BYTE, black);
-    }
-  }
-  glBindTexture(GL_TEXTURE_2D, 0);
-  glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+  default_texture_2d_ = CreateDefaultAndBlackTextures(
+      feature_info, GL_TEXTURE_2D, &black_2d_texture_id_);
+  default_texture_cube_map_ = CreateDefaultAndBlackTextures(
+      feature_info, GL_TEXTURE_CUBE_MAP, &black_cube_texture_id_);
 
-  // Since we are manually setting up these textures
-  // we need to manually manipulate some of the their bookkeeping.
-  num_unrenderable_textures_ += 2;
-  FeatureInfo temp_feature_info;
-  default_texture_2d_ = TextureInfo::Ref(new TextureInfo(ids[1]));
-  SetInfoTarget(feature_info, default_texture_2d_, GL_TEXTURE_2D);
-  SetLevelInfo(&temp_feature_info, default_texture_2d_,
-      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  default_texture_cube_map_ = TextureInfo::Ref(new TextureInfo(ids[3]));
-  SetInfoTarget(feature_info, default_texture_cube_map_, GL_TEXTURE_CUBE_MAP);
-  for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
-    SetLevelInfo(
-        &temp_feature_info, default_texture_cube_map_,
-        GLES2Util::IndexToGLFaceTarget(ii),
-        0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+  if (feature_info->feature_flags().oes_egl_image_external) {
+    default_texture_external_oes_ = CreateDefaultAndBlackTextures(
+        feature_info, GL_TEXTURE_EXTERNAL_OES,
+        &black_oes_external_texture_id_);
   }
 
-  black_2d_texture_id_ = ids[0];
-  black_cube_texture_id_ = ids[2];
-
-  if (feature_info->feature_flags().oes_egl_image_external) {
-    // Since we are manually setting up these textures
-    // we need to manually manipulate some of the their bookkeeping.
-    num_unrenderable_textures_ += 1;
-    GLuint external_ids[2];
-    glGenTextures(arraysize(external_ids), external_ids);
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
-    default_texture_external_oes_ = TextureInfo::Ref(
-        new TextureInfo(external_ids[0]));
-    SetInfoTarget(feature_info,
-                  default_texture_external_oes_,
-                  GL_TEXTURE_EXTERNAL_OES);
-    default_texture_external_oes_->SetLevelInfo(
-        &temp_feature_info, GL_TEXTURE_EXTERNAL_OES, 0,
-        GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-
-    // Sampling a texture not associated with any EGLImage sibling will return
-    // black values according to the spec.
-    black_oes_external_texture_id_ = external_ids[1];
+  if (feature_info->feature_flags().arb_texture_rectangle) {
+    default_texture_rectangle_arb_ = CreateDefaultAndBlackTextures(
+        feature_info, GL_TEXTURE_RECTANGLE_ARB,
+        &black_arb_texture_rectangle_id_);
   }
 
   return true;
 }
 
+TextureManager::TextureInfo::Ref TextureManager::CreateDefaultAndBlackTextures(
+    const FeatureInfo* feature_info,
+    GLenum target,
+    GLuint* black_texture) {
+  static uint8 black[] = {0, 0, 0, 255};
+
+  // Sampling a texture not associated with any EGLImage sibling will return
+  // black values according to the spec.
+  bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
+  bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
+
+  // Make default textures and texture for replacing non-renderable textures.
+  GLuint ids[2];
+  glGenTextures(arraysize(ids), ids);
+  for (unsigned long ii = 0; ii < arraysize(ids); ++ii) {
+    glBindTexture(target, ids[ii]);
+    if (needs_initialization) {
+      if (needs_faces) {
+        for (int jj = 0; jj < GLES2Util::kNumFaces; ++jj) {
+          glTexImage2D(GLES2Util::IndexToGLFaceTarget(jj), 0, GL_RGBA, 1, 1, 0,
+                       GL_RGBA, GL_UNSIGNED_BYTE, black);
+        }
+      } else {
+        glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
+                     GL_UNSIGNED_BYTE, black);
+      }
+    }
+  }
+  glBindTexture(target, 0);
+
+  // Since we are manually setting up these textures
+  // we need to manually manipulate some of the their bookkeeping.
+  ++num_unrenderable_textures_;
+  TextureInfo::Ref default_texture = TextureInfo::Ref(new TextureInfo(ids[1]));
+  SetInfoTarget(feature_info, default_texture, target);
+  FeatureInfo temp_feature_info;
+  if (needs_faces) {
+    for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
+      SetLevelInfo(
+          &temp_feature_info, default_texture,
+          GLES2Util::IndexToGLFaceTarget(ii),
+          0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+    }
+  } else {
+    // TODO(kbr): previous code called SetLevelInfo directly on the
+    // TextureInfo object for the GL_TEXTURE_EXTERNAL_OES case.
+    // Unclear whether this was deliberate.
+    if (needs_initialization) {
+      SetLevelInfo(&temp_feature_info, default_texture,
+                   GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                   GL_RGBA, GL_UNSIGNED_BYTE, true);
+    } else {
+      default_texture->SetLevelInfo(
+          &temp_feature_info, GL_TEXTURE_EXTERNAL_OES, 0,
+          GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+    }
+  }
+
+  *black_texture = ids[0];
+  return default_texture;
+}
+
 bool TextureManager::ValidForTarget(
     const FeatureInfo* feature_info,
     GLenum target, GLint level,
     GLsizei width, GLsizei height, GLsizei depth) {
   GLsizei max_size = MaxSizeForTarget(target);
   return level >= 0 &&
          width >= 0 &&
          height >= 0 &&
          depth >= 0 &&
          level < MaxLevelsForTarget(target) &&
@@ skipping 214 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu