gpu: If not cube complete, the texture isn't renderable, no matter mipmap complete.

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>
@@ skipping 197 matching lines @@
   friend class TextureDefinition;
   friend class TextureManager;
   friend class TextureRef;
   friend class TextureTestHelper;
 
   ~Texture();
   void AddTextureRef(TextureRef* ref);
   void RemoveTextureRef(TextureRef* ref, bool have_context);
   MemoryTypeTracker* GetMemTracker();
 
-  // Condition on which this texture is renderable. Can be ONLY_IF_NPOT if it
+  // Condition on which this texture is complete. Can be ONLY_IF_NPOT if it
   // depends on context support for non-power-of-two textures (i.e. will be
-  // renderable if NPOT support is in the context, otherwise not, e.g. texture
+  // complete 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.
+  // (e.g. complete POT), NEVER means it's not complete regardless (e.g.
   // incomplete).
-  enum CanRenderCondition {
-    CAN_RENDER_ALWAYS,
-    CAN_RENDER_NEVER,
-    CAN_RENDER_ONLY_IF_NPOT
+  // See section 3.7.10 of the GLES2 spec.
+  enum TextureCompleteness {
+    TEXTURE_COMPLETE_ALWAYS,
+    TEXTURE_INCOMPLETE,
+    TEXTURE_COMPLETE_ONLY_IF_NPOT
   };
 
   struct LevelInfo {
     LevelInfo();
     LevelInfo(const LevelInfo& rhs);
     ~LevelInfo();
 
     gfx::Rect cleared_rect;
     GLenum target;
     GLint level;
@@ skipping 25 matching lines @@
                     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_;
-  }
+  // See section 3.7.10 of the GLES2 spec.
+  bool texture_2d_complete() const { return texture_2d_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.
+  // See section 3.7.10 of the GLES2 spec.
   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.
@@ skipping 24 matching lines @@
       const FeatureInfo* feature_info, GLenum pname, GLfloat param);
 
   // Makes each of the mip levels as though they were generated.
   bool MarkMipmapsGenerated(const FeatureInfo* feature_info);
 
   bool NeedsMips() const {
     return min_filter_ != GL_NEAREST && min_filter_ != GL_LINEAR;
   }
 
   // True if this texture meets all the GLES2 criteria for rendering.
-  // See section 3.8.2 of the GLES2 spec.

[dshwang, 2015/08/17 16:20:41]

section 3.8.2 is "Shader Execution", which isn't related to this code.
https://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.25.pdf

[Ken Russell (switch to Gerrit), 2015/08/17 21:32:27]

On the contrary: it is related. In GLES2 a texture that's complete may still not
be renderable, and the renderability rules are described in section 3.8.2. In
particular, sampling a non-power-of-two texture will return (0, 0, 0, 1)
("non-renderable" by this code's definition) under some circumstances, though
that texture might still be complete according to the rules in section 3.7.10.

I have concerns that this CL is not the right direction to go.

[dshwang, 2015/08/18 07:18:16]

I see. Let me not change the name. mentioning section 3.8.2 is also correct.
thank you for explanation.

-  bool CanRender(const FeatureInfo* feature_info) const;
+  // See section 3.7.10 of the GLES2 spec.
+  bool IsTextureComplete(const FeatureInfo* feature_info) const;
 
   // Returns true if mipmaps can be generated by GL.
   bool CanGenerateMipmaps(const FeatureInfo* feature_info) const;
 
   // Returns true if any of the texture dimensions are not a power of two.
   static bool TextureIsNPOT(GLsizei width, GLsizei height, GLsizei depth);
 
   // Returns true if texture face is complete relative to the first face.
   static bool TextureFaceComplete(const Texture::LevelInfo& first_face,
                                   size_t face_index,
@@ skipping 46 matching lines @@
   // texture.
   void UpdateSafeToRenderFrom(bool cleared);
 
   // 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);
 
-  // Computes the CanRenderCondition flag.
-  CanRenderCondition GetCanRenderCondition() const;
+  // Computes the TextureCompleteness flag.
+  TextureCompleteness GetTextureCompleteness() const;
 
   // Updates the unrenderable texture count in all the managers referencing this
   // texture.
-  void UpdateCanRenderCondition();
+  void UpdateTextureCompleteness();
 
   // Updates the images count in all the managers referencing this
   // texture.
   void UpdateHasImages();
 
   // Increment the framebuffer state change count in all the managers
   // referencing this texture.
   void IncAllFramebufferStateChangeCount();
 
   MailboxManager* mailbox_manager_;
@@ skipping 34 matching lines @@
   GLenum compare_mode_;
   GLfloat max_lod_;
   GLfloat min_lod_;
   GLint base_level_;
   GLint max_level_;
 
   // The maximum level that has been set.
   GLint max_level_set_;
 
   // Whether or not this texture is "texture complete"
-  bool texture_complete_;
+  bool texture_2d_complete_;
 
   // Whether mip levels have changed and should be reverified.
   bool texture_mips_dirty_;
   bool texture_mips_complete_;
 
   // Whether or not this texture is "cube complete"
   bool cube_complete_;
 
   // Whether any level 0 faces have changed and should be reverified.
   bool texture_level0_dirty_;
@@ skipping 11 matching lines @@
   // Whether the texture is immutable and no further changes to the format
   // or dimensions of the texture object can be made.
   bool immutable_;
 
   // Whether or not this texture has images.
   bool has_images_;
 
   // Size in bytes this texture is assumed to take in memory.
   uint32 estimated_size_;
 
-  // Cache of the computed CanRenderCondition flag.
-  CanRenderCondition can_render_condition_;
+  // Cache of the computed TextureCompleteness flag.
+  TextureCompleteness texture_completeness;
 
   // Whether we have initialized TEXTURE_MAX_ANISOTROPY to 1.
   bool texture_max_anisotropy_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 // This class represents a texture in a client context group. It's mostly 1:1
 // with a client id, though it can outlive the client id if it's still bound to
 // a FBO or another context when destroyed.
@@ skipping 141 matching lines @@
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth);
 
   // Checks if a dimensions are valid for a given target.
   bool ValidForTarget(
       GLenum target, GLint level,
       GLsizei width, GLsizei height, GLsizei depth);
 
   // True if this texture meets all the GLES2 criteria for rendering.
-  // See section 3.8.2 of the GLES2 spec.
-  bool CanRender(const TextureRef* ref) const {
-    return ref->texture()->CanRender(feature_info_.get());
+  // See section 3.7.10 of the GLES2 spec.
+  bool IsTextureComplete(const TextureRef* ref) const {
+    return ref->texture()->IsTextureComplete(feature_info_.get());
   }
 
   // Returns true if mipmaps can be generated by GL.
   bool CanGenerateMipmaps(const TextureRef* ref) const {
     return ref->texture()->CanGenerateMipmaps(feature_info_.get());
   }
 
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP
@@ skipping 227 matching lines @@
     DecoderFramebufferState* framebuffer_state,
     const char* function_name,
     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 UpdateTextureCompleteness(Texture::TextureCompleteness old_completeness,
+                                 Texture::TextureCompleteness new_completeness);
   void UpdateNumImages(int delta);
   void IncFramebufferStateChangeCount();
 
   GLenum AdjustTexFormat(GLenum format) const;
 
   // Helper function called by OnMemoryDump.
   void DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
                       TextureRef* ref);
 
   MemoryTypeTracker* GetMemTracker(GLenum texture_pool);
@@ skipping 52 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_