gpu: Use a rectangle to keep track of the cleared area of each texture level.

gpu/command_buffer/service/texture_manager.h

 // 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 GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
+#include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_image.h"
 
 namespace gpu {
 namespace gles2 {
 
 class GLES2Decoder;
 struct ContextState;
 struct DecoderFramebufferState;
 class Display;
 class ErrorState;
@@ skipping 55 matching lines @@
   }
 
   GLint base_level() const {
     return base_level_;
   }
 
   GLint max_level() const {
     return max_level_;
   }
 
-  int num_uncleared_mips() const {
-    return num_uncleared_mips_;
-  }
-
   uint32 estimated_size() const {
     return estimated_size_;
   }
 
   bool CanRenderTo() const {
     return target_ != GL_TEXTURE_EXTERNAL_OES;
   }
 
   // The service side OpenGL id of the texture.
   GLuint service_id() const {
@@ skipping 66 matching lines @@
   }
 
   void SetImmutable(bool immutable) {
     immutable_ = immutable;
   }
 
   bool IsImmutable() const {
     return immutable_;
   }
 
+  // Get the cleared rectangle for a particular level. Returns an empty
+  // rectangle if level does not exist.
+  gfx::Rect GetLevelClearedRect(GLenum target, GLint level) const;
+
   // Whether a particular level/face is cleared.
   bool IsLevelCleared(GLenum target, GLint level) const;
 
   // Whether the texture has been defined
   bool IsDefined() const {
     return estimated_size() > 0;
   }
 
   // Initialize TEXTURE_MAX_ANISOTROPY to 1 if we haven't done so yet.
   void InitTextureMaxAnisotropyIfNeeded(GLenum target);
@@ skipping 25 matching lines @@
     CAN_RENDER_ALWAYS,
     CAN_RENDER_NEVER,
     CAN_RENDER_ONLY_IF_NPOT
   };
 
   struct LevelInfo {
     LevelInfo();
     LevelInfo(const LevelInfo& rhs);
     ~LevelInfo();
 
-    bool cleared;
+    gfx::Rect cleared_rect;
     GLenum target;
     GLint level;
     GLenum internal_format;
     GLsizei width;
     GLsizei height;
     GLsizei depth;
     GLint border;
     GLenum format;
     GLenum type;
     scoped_refptr<gfx::GLImage> image;
     uint32 estimated_size;
   };
 
   struct FaceInfo {
     FaceInfo();
     ~FaceInfo();
 
     GLsizei num_mip_levels;
     std::vector<LevelInfo> level_infos;
   };
 
   // Set the info for a particular level.
-  void SetLevelInfo(
-      const FeatureInfo* feature_info,
-      GLenum target,
-      GLint level,
-      GLenum internal_format,
-      GLsizei width,
-      GLsizei height,
-      GLsizei depth,
-      GLint border,
-      GLenum format,
-      GLenum type,
-      bool cleared);
+  void SetLevelInfo(const FeatureInfo* feature_info,
+                    GLenum target,
+                    GLint level,
+                    GLenum internal_format,
+                    GLsizei width,
+                    GLsizei height,
+                    GLsizei depth,
+                    GLint border,
+                    GLenum format,
+                    GLenum type,
+                    const gfx::Rect& cleared_rect);
 
   // In GLES2 "texture complete" means it has all required mips for filtering
   // down to a 1x1 pixel texture, they are in the correct order, they are all
   // the same format.
   bool texture_complete() const {
     return texture_complete_;
   }
 
   // In GLES2 "cube complete" means all 6 faces level 0 are defined, all the
   // same format, all the same dimensions and all width = height.
   bool cube_complete() const {
     return cube_complete_;
   }
 
   // Whether or not this texture is a non-power-of-two texture.
   bool npot() const {
     return npot_;
   }
 
+  // Marks a |rect| of a particular level as cleared.
+  void SetLevelClearedRect(GLenum target,
+                           GLint level,
+                           const gfx::Rect& cleared_rect);
+
   // Marks a particular level as cleared or uncleared.
   void SetLevelCleared(GLenum target, GLint level, bool cleared);
 
-  // Updates the cleared flag for this texture by inspecting all the mips.
-  void UpdateCleared();
-
   // Clears any renderable uncleared levels.
   // Returns false if a GL error was generated.
   bool ClearRenderableLevels(GLES2Decoder* decoder);
 
   // Clears the level.
   // Returns false if a GL error was generated.
   bool ClearLevel(GLES2Decoder* decoder, GLenum target, GLint level);
 
   // Sets a texture parameter.
   // TODO(gman): Expand to SetParameteriv,fv
@@ skipping 63 matching lines @@
 
   // Appends a signature for the given level.
   void AddToSignature(
       const FeatureInfo* feature_info,
       GLenum target, GLint level, std::string* signature) const;
 
   void SetMailboxManager(MailboxManager* mailbox_manager);
 
   // Updates the unsafe textures count in all the managers referencing this
   // texture.
-  void UpdateSafeToRenderFrom(bool cleared);
-
-  // Updates the uncleared mip count in all the managers referencing this
-  // texture.
-  void UpdateMipCleared(LevelInfo* info, bool cleared);
+  void UpdateSafeToRenderFrom();
 
   // Computes the CanRenderCondition flag.
   CanRenderCondition GetCanRenderCondition() const;
 
   // Updates the unrenderable texture count in all the managers referencing this
   // texture.
   void UpdateCanRenderCondition();
 
   // Updates the images count in all the managers referencing this
   // texture.
@@ skipping 15 matching lines @@
   // The single TextureRef that accounts for memory for this texture. Must be
   // one of refs_.
   TextureRef* memory_tracking_ref_;
 
   // The id of the texure
   GLuint service_id_;
 
   // Whether all renderable mips of this texture have been cleared.
   bool cleared_;
 
-  int num_uncleared_mips_;
   int num_npot_faces_;
 
   // The target. 0 if unset, otherwise GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.
   //             Or GL_TEXTURE_2D_ARRAY or GL_TEXTURE_3D (for GLES3).
   GLenum target_;
 
   // Texture parameters.
   GLenum min_filter_;
   GLenum mag_filter_;
   GLenum wrap_r_;
@@ skipping 218 matching lines @@
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP
   //           GL_TEXTURE_2D_ARRAY or GL_TEXTURE_3D (for GLES3)
   //   max_levels: The maximum levels this type of target can have.
   void SetTarget(
       TextureRef* ref,
       GLenum target);
 
   // Set the info for a particular level in a TexureInfo.
-  void SetLevelInfo(
-      TextureRef* ref,
-      GLenum target,
-      GLint level,
-      GLenum internal_format,
-      GLsizei width,
-      GLsizei height,
-      GLsizei depth,
-      GLint border,
-      GLenum format,
-      GLenum type,
-      bool cleared);
+  void SetLevelInfo(TextureRef* ref,
+                    GLenum target,
+                    GLint level,
+                    GLenum internal_format,
+                    GLsizei width,
+                    GLsizei height,
+                    GLsizei depth,
+                    GLint border,
+                    GLenum format,
+                    GLenum type,
+                    const gfx::Rect& cleared_rect);
 
   // Adapter to call above function.
   void SetLevelInfoFromParams(TextureRef* ref,
                               const gpu::AsyncTexImage2DParams& params) {
-    SetLevelInfo(
-        ref, params.target, params.level, params.internal_format,
-        params.width, params.height, 1 /* depth */,
-        params.border, params.format,
-        params.type, true /* cleared */);
+    SetLevelInfo(ref, params.target, params.level, params.internal_format,
+                 params.width, params.height, 1 /* depth */, params.border,
+                 params.format, params.type,
+                 gfx::Rect(params.width, params.height) /* cleared_rect */);
   }
 
   Texture* Produce(TextureRef* ref);
 
   // Maps an existing texture into the texture manager, at a given client ID.
   TextureRef* Consume(GLuint client_id, Texture* texture);
 
+  // Sets |rect| of mip as cleared.
+  void SetLevelClearedRect(TextureRef* ref,
+                           GLenum target,
+                           GLint level,
+                           const gfx::Rect& cleared_rect);
+
   // Sets a mip as cleared.
   void SetLevelCleared(TextureRef* ref, GLenum target,
                        GLint level, bool cleared);
 
   // Sets a texture parameter of a Texture
   // Returns GL_NO_ERROR on success. Otherwise the error to generate.
   // TODO(gman): Expand to SetParameteriv,fv
   void SetParameteri(
       const char* function_name, ErrorState* error_state,
       TextureRef* ref, GLenum pname, GLint param);
@@ skipping 42 matching lines @@
   }
 
   bool HaveUnrenderableTextures() const {
     return num_unrenderable_textures_ > 0;
   }
 
   bool HaveUnsafeTextures() const {
     return num_unsafe_textures_ > 0;
   }
 
-  bool HaveUnclearedMips() const {
-    return num_uncleared_mips_ > 0;
-  }
-
   bool HaveImages() const {
     return num_images_ > 0;
   }
 
   GLuint black_texture_id(GLenum target) const {
     switch (target) {
       case GL_SAMPLER_2D:
         return black_texture_ids_[kTexture2D];
       case GL_SAMPLER_CUBE:
         return black_texture_ids_[kCubeMap];
@@ skipping 99 matching lines @@
     DecoderTextureState* texture_state,
     ErrorState* error_state,
     DecoderFramebufferState* framebuffer_state,
     TextureRef* texture_ref,
     const DoTexImageArguments& args);
 
   void StartTracking(TextureRef* texture);
   void StopTracking(TextureRef* texture);
 
   void UpdateSafeToRenderFrom(int delta);
-  void UpdateUnclearedMips(int delta);
   void UpdateCanRenderCondition(Texture::CanRenderCondition old_condition,
                                 Texture::CanRenderCondition new_condition);
   void UpdateNumImages(int delta);
   void IncFramebufferStateChangeCount();
 
   GLenum AdjustTexFormat(GLenum format) const;
 
   MemoryTypeTracker* GetMemTracker(GLenum texture_pool);
   scoped_ptr<MemoryTypeTracker> memory_tracker_managed_;
   scoped_ptr<MemoryTypeTracker> memory_tracker_unmanaged_;
@@ skipping 11 matching lines @@
   GLsizei max_rectangle_texture_size_;
   GLsizei max_3d_texture_size_;
   GLint max_levels_;
   GLint max_cube_map_levels_;
   GLint max_3d_levels_;
 
   const bool use_default_textures_;
 
   int num_unrenderable_textures_;
   int num_unsafe_textures_;
-  int num_uncleared_mips_;
   int num_images_;
 
   // Counts the number of Textures allocated with 'this' as its manager.
   // Allows to check no Texture will outlive this.
   unsigned int texture_count_;
 
   bool have_context_;
 
   // Black (0,0,0,1) textures for when non-renderable textures are used.
   // NOTE: There is no corresponding Texture for these textures.
@@ skipping 17 matching lines @@
  private:
   DecoderTextureState* texture_state_;
   base::TimeTicks begin_time_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTextureUploadTimer);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_