Command buffer: clear rect for a specific layer/level of the uncleared texture for CopyTexSubImage3D

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 163 matching lines @@
   // Get the type of a level. Returns false if level does not exist.
   bool GetLevelType(
       GLint target, GLint level, GLenum* type, GLenum* internal_format) const;
 
   // Set the image for a particular level. If a GLStreamTextureImage was
   // previously set with SetLevelStreamTextureImage(), this will reset
   // |service_id_| back to |owned_service_id_|, removing the service id override
   // set by the GLStreamTextureImage.
   void SetLevelImage(GLenum target,
                      GLint level,
+                     GLint layer,
                      gl::GLImage* image,
                      ImageState state);
 
   // Set the GLStreamTextureImage for a particular level.  This is like
   // SetLevelImage, but it also makes it optional to override |service_id_| with
   // a texture bound to the stream texture, and permits
   // GetLevelStreamTextureImage to return the image. See
   // SetStreamTextureServiceId() for the details of how |service_id| is used.
   void SetLevelStreamTextureImage(GLenum target,
                                   GLint level,
+                                  GLint layer,
                                   GLStreamTextureImage* image,
                                   ImageState state,
                                   GLuint service_id);
 
   // Set the ImageState for the image bound to the given level.
-  void SetLevelImageState(GLenum target, GLint level, ImageState state);
+  void SetLevelImageState(GLenum target,
+                          GLint level,
+                          GLint layer,
+                          ImageState state);
 
 
   // Get the image associated with a particular level. Returns NULL if level
   // does not exist.
   gl::GLImage* GetLevelImage(GLint target,
                              GLint level,
+                             GLint layer,
                              ImageState* state) const;
-  gl::GLImage* GetLevelImage(GLint target, GLint level) const;
+  gl::GLImage* GetLevelImage(GLint target, GLint level, GLint layer) const;
 
   // Like GetLevelImage, but will return NULL if the image wasn't set via
   // a call to SetLevelStreamTextureImage.
   GLStreamTextureImage* GetLevelStreamTextureImage(GLint target,
-                                                   GLint level) const;
+                                                   GLint level,
+                                                   GLint layer) const;
 
   bool HasImages() const {
     return has_images_;
   }
 
   // Returns true of the given dimensions are inside the dimensions of the
   // level.
   bool ValidForTexture(
       GLint target,
       GLint level,
@@ skipping 27 matching lines @@
 
   bool IsImmutable() const {
     return immutable_;
   }
 
   // Return 0 if it's not immutable.
   GLint GetImmutableLevels() const;
 
   // 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;
+  gfx::Rect GetLevelClearedRect(GLenum target, GLint level, GLint layer) const;
+  // TODO(yunchao) Wrap the original GetLevelClearedRect on the basis of
+  // GetLayerClearedRect. The origianl GetLevelClearedRect for 2D texture
+  // Will be not aware of parameter layer.
+  // Do the same for SetLevelClearedRect, isLevelCleared, etc.
+  // gfx::Rect GetLevelClearedRect(GLenum target, GLint level) const {
+  //     GetLayerClearedRect(target, level, 0);
+  // }
+  //
+  // gfx::Rect GetLayerClearedRect(GLenum target,
+  //                               GLint level,
+  //                               GLint layer) const;
 
   // Whether a particular level/face is cleared.
-  bool IsLevelCleared(GLenum target, GLint level) const;
+  bool IsLevelCleared(GLenum target, GLint level, GLint layer) const;
   // Whether a particular level/face is partially cleared.
-  bool IsLevelPartiallyCleared(GLenum target, GLint level) const;
+  bool IsLevelPartiallyCleared(GLenum target,
+                               GLint level,
+                               GLint layer) 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);
 
   void DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
@@ skipping 23 matching lines @@
   // renderable if NPOT support is in the context, otherwise not, e.g. texture
   // with a NPOT level). ALWAYS means it doesn't depend on context features
   // (e.g. complete POT), NEVER means it's not renderable regardless (e.g.
   // incomplete).
   enum CanRenderCondition {
     CAN_RENDER_ALWAYS,
     CAN_RENDER_NEVER,
     CAN_RENDER_NEEDS_VALIDATION,
   };
 
+  struct LayerInfo {
+    LayerInfo();
+    LayerInfo(const LayerInfo& rhs);
+    ~LayerInfo();
+
+    gfx::Rect cleared_rect;
+    scoped_refptr<gl::GLImage> image;
+    scoped_refptr<GLStreamTextureImage> stream_texture_image;
+    ImageState image_state;
+    // This variable may be not useful;
+    GLint layer;
+  };
+
   struct LevelInfo {
     LevelInfo();
     LevelInfo(const LevelInfo& rhs);
     ~LevelInfo();
 
-    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<gl::GLImage> image;
-    scoped_refptr<GLStreamTextureImage> stream_texture_image;
-    ImageState image_state;
     uint32_t estimated_size;
     bool internal_workaround;
+    int num_uncleared_layers;
+
+    std::vector<LayerInfo> layer_infos;
   };
 
   struct FaceInfo {
     FaceInfo();
     FaceInfo(const FaceInfo& other);
     ~FaceInfo();
 
     // This is relative to base_level and max_level of a texture.
     GLsizei num_mip_levels;
     // This contains slots for all levels starting at 0.
     std::vector<LevelInfo> level_infos;
   };
 
   // Helper for SetLevel*Image.  |stream_texture_image| may be null.
   void SetLevelImageInternal(GLenum target,
                              GLint level,
+                             GLint layer,
                              gl::GLImage* image,
                              GLStreamTextureImage* stream_texture_image,
                              ImageState state);
 
   // Returns the LevelInfo for |target| and |level| if it's set, else NULL.
   const LevelInfo* GetLevelInfo(GLint target, GLint level) const;
 
   // Set the info for a particular level.
   void SetLevelInfo(GLenum target,
                     GLint level,
@@ skipping 28 matching lines @@
   }
 
   // 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,
+                           GLint layer,
                            const gfx::Rect& cleared_rect);
 
   // Marks a particular level as cleared or uncleared.
-  void SetLevelCleared(GLenum target, GLint level, bool cleared);
+  void SetLevelCleared(GLenum target, GLint level, GLint layer, 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);
+  bool ClearLevel(GLES2Decoder* decoder,
+                  GLenum target,
+                  GLint level,
+                  GLint layer);
 
   // Sets a texture parameter.
   // TODO(gman): Expand to SetParameteriv,fv
   // Returns GL_NO_ERROR on success. Otherwise the error to generate.
   GLenum SetParameteri(
       const FeatureInfo* feature_info, GLenum pname, GLint param);
   GLenum SetParameterf(
       const FeatureInfo* feature_info, GLenum pname, GLfloat param);
 
   // Makes each of the mip levels as though they were generated.
@@ skipping 45 matching lines @@
   static bool TextureFilterable(const FeatureInfo* feature_info,
                                 GLenum internal_format,
                                 GLenum type);
 
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP or
   //           GL_TEXTURE_EXTERNAL_OES or GL_TEXTURE_RECTANGLE_ARB
   //           GL_TEXTURE_2D_ARRAY or GL_TEXTURE_3D (for GLES3)
   //   max_levels: The maximum levels this type of target can have.
-  void SetTarget(GLenum target, GLint max_levels);
+  void SetTarget(GLenum target, GLint max_levels, GLint layers);
 
   // Update info about this texture.
   void Update();
 
   // Appends a signature for the given level.
   void AddToSignature(
       const FeatureInfo* feature_info,
-      GLenum target, GLint level, std::string* signature) const;
+      GLenum target, GLint level, GLint layer, 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);
 
+  void UpdateMipClearedHelper(LevelInfo* info);
+
   // Updates the uncleared mip count in all the managers referencing this
   // texture.
   void UpdateMipCleared(LevelInfo* info,
                         GLsizei width,
                         GLsizei height,
-                        const gfx::Rect& cleared_rect);
+                        const gfx::Rect& cleared_rect,
+                        GLint layer);
 
   // 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 264 matching lines @@
         return max_texture_size_;
       case GL_TEXTURE_RECTANGLE:
         return max_rectangle_texture_size_;
       case GL_TEXTURE_3D:
         return max_3d_texture_size_;
       default:
         return max_cube_map_texture_size_;
     }
   }
 
+  GLsizei max_3d_texture_size() const {
+    return max_3d_texture_size_;
+  }
+
   GLsizei max_array_texture_layers() const {
     return max_array_texture_layers_;
   }
 
   // Returns the maxium number of levels a texture of the given size can have.
   static GLsizei ComputeMipMapCount(GLenum target,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth);
 
@@ skipping 46 matching lines @@
 
   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,
+                           GLint layer,
                            const gfx::Rect& cleared_rect);
 
   // Sets a mip as cleared.
   void SetLevelCleared(TextureRef* ref, GLenum target,
-                       GLint level, bool cleared);
+                       GLint level, GLint layer, 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);
   void SetParameterf(
       const char* function_name, ErrorState* error_state,
       TextureRef* ref, GLenum pname, GLfloat param);
@@ skipping 73 matching lines @@
     }
   }
 
   size_t mem_represented() const {
     return memory_type_tracker_->GetMemRepresented();
   }
 
   void SetLevelImage(TextureRef* ref,
                      GLenum target,
                      GLint level,
+                     GLint layer,
                      gl::GLImage* image,
                      Texture::ImageState state);
 
   void SetLevelStreamTextureImage(TextureRef* ref,
                                   GLenum target,
                                   GLint level,
+                                  GLint layer,
                                   GLStreamTextureImage* image,
                                   Texture::ImageState state,
                                   GLuint service_id);
 
   void SetLevelImageState(TextureRef* ref,
                           GLenum target,
                           GLint level,
+                          GLint layer,
                           Texture::ImageState state);
 
   size_t GetSignatureSize() const;
 
   void AddToSignature(
       TextureRef* ref,
       GLenum target,
       GLint level,
+      GLint layer,
       std::string* signature) const;
 
   void AddObserver(DestructionObserver* observer) {
     destruction_observers_.push_back(observer);
   }
 
   void RemoveObserver(DestructionObserver* observer) {
     for (unsigned int i = 0; i < destruction_observers_.size(); i++) {
       if (destruction_observers_[i] == observer) {
         std::swap(destruction_observers_[i], destruction_observers_.back());
@@ skipping 220 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_