Upgrade TexSubImage3D and TexStorage3D.

gpu/command_buffer/service/texture_manager.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.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1832 matching lines @@
   return NULL;
 }
 
 GLsizei TextureManager::ComputeMipMapCount(GLenum target,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth) {
   switch (target) {
     case GL_TEXTURE_EXTERNAL_OES:
       return 1;
+    case GL_TEXTURE_3D:
+      return 1 +
+             base::bits::Log2Floor(std::max(std::max(width, height), depth));
     default:
       return 1 +
-             base::bits::Log2Floor(std::max(std::max(width, height), depth));
+             base::bits::Log2Floor(std::max(width, height));
   }
 }
 
 void TextureManager::SetLevelImage(TextureRef* ref,
                                    GLenum target,
                                    GLint level,
                                    gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(target, level, image, state);
@@ skipping 254 matching lines @@
              function_name, texture_ref, args);
 }
 
 bool TextureManager::ValidateTexSubImage(ContextState* state,
                                          const char* function_name,
                                          const DoTexSubImageArguments& args,
                                          TextureRef** texture_ref) {
   ErrorState* error_state = state->GetErrorState();
   const Validators* validators = feature_info_->validators();
 
-  if (!validators->texture_target.IsValid(args.target)) {
+  if ((args.command_type == DoTexSubImageArguments::kTexSubImage2D &&
+       !validators->texture_target.IsValid(args.target)) ||
+      (args.command_type == DoTexSubImageArguments::kTexSubImage3D &&
+       !validators->texture_3_d_target.IsValid(args.target))) {
     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(error_state, function_name,
                                          args.target, "target");
     return false;
   }
   if (args.width < 0) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
                             "width < 0");
     return false;
   }
   if (args.height < 0) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
                             "height < 0");
     return false;
   }
+  if (args.depth < 0) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
+                            "depth < 0");
+    return false;
+  }
   TextureRef* local_texture_ref = GetTextureInfoForTarget(state, args.target);
   if (!local_texture_ref) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             "unknown texture for target");
     return false;
   }
   Texture* texture = local_texture_ref->texture();
   GLenum current_type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(args.target, args.level, &current_type,
                              &internal_format)) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             "level does not exist.");
     return false;
   }
   if (!ValidateTextureParameters(error_state, function_name, args.format,
                                  args.type, internal_format, args.level)) {
     return false;
   }
   if (args.type != current_type && !feature_info_->IsES3Enabled()) {
+    // It isn't explicitly required in the ES2 spec, but some drivers generate
+    // an error. It is better to be consistent across drivers.
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
                             "type does not match type of texture.");
     return false;
   }
-  if (!texture->ValidForTexture(args.target, args.level, args.xoffset,
-                                args.yoffset, 0, args.width, args.height, 1)) {
+  if (!texture->ValidForTexture(args.target, args.level,
+                                args.xoffset, args.yoffset, args.zoffset,
+                                args.width, args.height, args.depth)) {
     ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
                             "bad dimensions.");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(args.format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 &&
       !feature_info_->IsES3Enabled()) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION, function_name,
         "can not supply data for depth or stencil textures");
@@ skipping 13 matching lines @@
     const DoTexSubImageArguments& args) {
   ErrorState* error_state = state->GetErrorState();
   TextureRef* texture_ref;
   if (!ValidateTexSubImage(state, function_name, args, &texture_ref)) {
     return;
   }
 
   Texture* texture = texture_ref->texture();
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
+  GLsizei tex_depth = 0;
   bool ok = texture->GetLevelSize(args.target, args.level, &tex_width,
-                                  &tex_height, nullptr);
+                                  &tex_height, &tex_depth);
   DCHECK(ok);
-  if (args.xoffset != 0 || args.yoffset != 0 || args.width != tex_width ||
-      args.height != tex_height) {
+  if (args.xoffset != 0 || args.yoffset != 0 || args.zoffset != 0 ||
+      args.width != tex_width || args.height != tex_height ||
+      args.depth != tex_depth) {
+    // TODO(zmo): Implement clearing of 3D textures. crbug.com/597201.
     gfx::Rect cleared_rect;
     if (CombineAdjacentRects(
             texture->GetLevelClearedRect(args.target, args.level),
             gfx::Rect(args.xoffset, args.yoffset, args.width, args.height),
             &cleared_rect)) {
       DCHECK_GE(cleared_rect.size().GetArea(),
                 texture->GetLevelClearedRect(args.target, args.level)
                     .size()
                     .GetArea());
       SetLevelClearedRect(texture_ref, args.target, args.level, cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!ClearTextureLevel(decoder, texture_ref, args.target, args.level)) {
         ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY,
-                                "glTexSubImage2D", "dimensions too big");
+                                function_name, "dimensions too big");
         return;
       }
     }
     ScopedTextureUploadTimer timer(texture_state);
-    glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
-                    args.width, args.height, AdjustTexFormat(args.format),
-                    args.type, args.pixels);
-    return;
+    if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
+      glTexSubImage3D(args.target, args.level, args.xoffset, args.yoffset,
+                      args.zoffset, args.width, args.height, args.depth,
+                      AdjustTexFormat(args.format), args.type, args.pixels);
+    } else {
+      glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
+                      args.width, args.height, AdjustTexFormat(args.format),
+                      args.type, args.pixels);
+      return;
+    }
   }
 
   if (!texture_state->texsubimage_faster_than_teximage &&
       !texture->IsImmutable() && !texture->HasImages()) {
     ScopedTextureUploadTimer timer(texture_state);
     GLenum internal_format;
     GLenum tex_type;
     texture->GetLevelType(args.target, args.level, &tex_type, &internal_format);
-    // NOTE: In OpenGL ES 2.0 border is always zero. If that changes we'll need
+    // NOTE: In OpenGL ES 2/3 border is always zero. If that changes we'll need
     // to look it up.
-    glTexImage2D(args.target, args.level, internal_format, args.width,
-                 args.height, 0, AdjustTexFormat(args.format), args.type,
-                 args.pixels);
+    if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
+      glTexImage3D(args.target, args.level, internal_format, args.width,
+                   args.height, args.depth, 0, AdjustTexFormat(args.format),
+                   args.type, args.pixels);
+    } else {
+      glTexImage2D(args.target, args.level, internal_format, args.width,
+                   args.height, 0, AdjustTexFormat(args.format), args.type,
+                   args.pixels);
+    }
   } else {
     ScopedTextureUploadTimer timer(texture_state);
-    glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
-                    args.width, args.height, AdjustTexFormat(args.format),
-                    args.type, args.pixels);
+    if (args.command_type == DoTexSubImageArguments::kTexSubImage3D) {
+      glTexSubImage3D(args.target, args.level, args.xoffset, args.yoffset,
+                      args.zoffset, args.width, args.height, args.depth,
+                      AdjustTexFormat(args.format), args.type, args.pixels);
+    } else {
+      glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
+                      args.width, args.height, AdjustTexFormat(args.format),
+                      args.type, args.pixels);
+    }
   }
   SetLevelCleared(texture_ref, args.target, args.level, true);
   return;
 }
 
 GLenum TextureManager::AdjustTexFormat(GLenum format) const {
   // TODO(bajones): GLES 3 allows for internal format and format to differ.
   // This logic may need to change as a result.
   if (gfx::GetGLImplementation() == gfx::kGLImplementationDesktopGL) {
     if (format == GL_SRGB_EXT)
@@ skipping 20 matching lines @@
   bool level_is_same =
       texture->GetLevelSize(
           args.target, args.level, &tex_width, &tex_height, &tex_depth) &&
       texture->GetLevelType(args.target, args.level, &tex_type, &tex_format) &&
       args.width == tex_width && args.height == tex_height &&
       args.depth == tex_depth && args.type == tex_type &&
       args.format == tex_format;
 
   if (level_is_same && !args.pixels) {
     // Just set the level texture but mark the texture as uncleared.
-    SetLevelInfo(texture_ref, args.target, args.level, args.internal_format,
-                 args.width, args.height, args.depth, args.border, args.format,
-                 args.type, gfx::Rect());
+    // TODO(zmo): Implement clearing of 3D textures. crbug.com/597201.
+    bool set_as_cleared =
+        (args.command_type == DoTexImageArguments::kTexImage3D);
+    SetLevelInfo(
+        texture_ref, args.target, args.level, args.internal_format, args.width,
+        args.height, args.depth, args.border, args.format, args.type,
+        set_as_cleared ? gfx::Rect(args.width, args.height) : gfx::Rect());
     texture_state->tex_image_failed = false;
     return;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state->clear_state_dirty = true;
   }
 
   if (texture_state->texsubimage_faster_than_teximage &&
       level_is_same && args.pixels) {
@@ skipping 30 matching lines @@
   }
   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, function_name);
   if (args.command_type == DoTexImageArguments::kTexImage3D) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("GPU.Error.TexImage3D", error,
         GetAllGLErrors());
   } else {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("GPU.Error.TexImage2D", error,
         GetAllGLErrors());
   }
   if (error == GL_NO_ERROR) {
+    // TODO(zmo): Implement clearing of 3D textures. crbug.com/597201.
+    bool set_as_cleared = (args.pixels != nullptr ||
+        args.command_type == DoTexImageArguments::kTexImage3D);
     SetLevelInfo(
         texture_ref, args.target, args.level, args.internal_format, args.width,
         args.height, args.depth, args.border, args.format, args.type,
-        args.pixels != NULL ? gfx::Rect(args.width, args.height) : gfx::Rect());
+        set_as_cleared ? gfx::Rect(args.width, args.height) : gfx::Rect());
     texture_state->tex_image_failed = false;
   }
 }
 
 bool TextureManager::CombineAdjacentRects(const gfx::Rect& rect1,
                                           const gfx::Rect& rect2,
                                           gfx::Rect* result) {
   // Return |rect2| if |rect1| is empty or |rect2| contains |rect1|.
   if (rect1.IsEmpty() || rect2.Contains(rect1)) {
     *result = rect2;
@@ skipping 349 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu