Implement support for rendering to 32-bit float textures on ES3

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 "base/bits.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
@@ skipping 499 matching lines @@
   }
 }
 
 bool Texture::ValidForTexture(
     GLint target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
-    GLenum format,
     GLenum type) const {
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     int32 right;
     int32 top;
     return SafeAddInt32(xoffset, width, &right) &&
            SafeAddInt32(yoffset, height, &top) &&
            xoffset >= 0 &&
            yoffset >= 0 &&
            right <= info.width &&
            top <= info.height &&
-           format == info.internal_format &&
            type == info.type;
   }
   return false;
 }
 
 bool Texture::GetLevelSize(
     GLint target, GLint level, GLsizei* width, GLsizei* height) const {
   DCHECK(width);
   DCHECK(height);
   size_t face_index = GLTargetToFaceIndex(target);
@@ skipping 707 matching lines @@
 void TextureManager::UpdateNumImages(int delta) {
   num_images_ += delta;
   DCHECK_GE(num_images_, 0);
 }
 
 void TextureManager::IncFramebufferStateChangeCount() {
   if (framebuffer_manager_)
     framebuffer_manager_->IncFramebufferStateChangeCount();
 }
 
-bool TextureManager::ValidateTextureParameters(
-    ErrorState* error_state, const char* function_name,
-    GLenum target, GLenum format, GLenum type, GLint level) {
+bool TextureManager::ValidateFormatAndTypeCombination(
+    ErrorState* error_state, const char* function_name, GLenum format,
+    GLenum type) {
   if (!feature_info_->GetTextureFormatValidator(format).IsValid(type)) {
-      ERRORSTATE_SET_GL_ERROR(
-          error_state, GL_INVALID_OPERATION, function_name,
-          (std::string("invalid type ") +
-           GLES2Util::GetStringEnum(type) + " for format " +
-           GLES2Util::GetStringEnum(format)).c_str());
-      return false;
-  }
-
-  uint32 channels = GLES2Util::GetChannelsForFormat(format);
-  if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION, function_name,
         (std::string("invalid type ") +
          GLES2Util::GetStringEnum(type) + " for format " +
          GLES2Util::GetStringEnum(format)).c_str());
     return false;
   }
   return true;
 }
 
+bool TextureManager::ValidateTextureParameters(
+    ErrorState* error_state, const char* function_name,
+    GLenum format, GLenum type, GLenum internal_format, GLint level) {
+  const Validators* validators = feature_info_->validators();
+  if (!validators->texture_format.IsValid(format)) {
+    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
+        error_state, function_name, format, "format");
+    return false;
+  }
+  if (!validators->pixel_type.IsValid(type)) {
+    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
+        error_state, function_name, type, "type");
+    return false;
+  }
+  if (format != internal_format &&
+      !((internal_format == GL_RGBA32F && format == GL_RGBA) ||
+        (internal_format == GL_RGB32F && format == GL_RGB))) {
+    ERRORSTATE_SET_GL_ERROR(
+        error_state, GL_INVALID_OPERATION, function_name,
+        "format != internalformat");
+    return false;
+  }
+  uint32 channels = GLES2Util::GetChannelsForFormat(format);
+  if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
+    ERRORSTATE_SET_GL_ERROR(
+        error_state, GL_INVALID_OPERATION, function_name,
+        (std::string("invalid format ") + GLES2Util::GetStringEnum(format) +
+         " for level != 0").c_str());
+    return false;
+  }
+  return ValidateFormatAndTypeCombination(error_state, function_name,
+      format, type);
+}
+
 // Gets the texture id for a given target.
 TextureRef* TextureManager::GetTextureInfoForTarget(
     ContextState* state, GLenum target) {
   TextureUnit& unit = state->texture_units[state->active_texture_unit];
   TextureRef* texture = NULL;
   switch (target) {
     case GL_TEXTURE_2D:
       texture = unit.bound_texture_2d.get();
       break;
     case GL_TEXTURE_CUBE_MAP:
@@ skipping 33 matching lines @@
     const char* function_name,
     const DoTextImage2DArguments& args,
     TextureRef** texture_ref) {
   ErrorState* error_state = state->GetErrorState();
   const Validators* validators = feature_info_->validators();
   if (!validators->texture_target.IsValid(args.target)) {
     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
         error_state, function_name, args.target, "target");
     return false;
   }
-  if (!validators->texture_format.IsValid(args.internal_format)) {
+  if (!validators->texture_internal_format.IsValid(args.internal_format)) {
     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
         error_state, function_name, args.internal_format,
-        "internal_format");
-    return false;
-  }
-  if (!validators->texture_format.IsValid(args.format)) {
-    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
-        error_state, function_name, args.format, "format");
-    return false;
-  }
-  if (!validators->pixel_type.IsValid(args.type)) {
-    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
-        error_state, function_name, args.type, "type");
-    return false;
-  }
-  if (args.format != args.internal_format) {
-    ERRORSTATE_SET_GL_ERROR(
-        error_state, GL_INVALID_OPERATION, function_name,
-        "format != internalFormat");
+        "internalformat");
     return false;
   }
   if (!ValidateTextureParameters(
-      error_state, function_name, args.target, args.format, args.type,
-      args.level)) {
+      error_state, function_name, args.format, args.type,
+      args.internal_format, args.level)) {
     return false;
   }
   if (!ValidForTarget(args.target, args.level, args.width, args.height, 1) ||
       args.border != 0) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_VALUE, function_name,
         "dimensions out of range");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(args.format) &
@@ skipping 15 matching lines @@
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_INVALID_OPERATION, function_name,
         "texture is immutable");
     return false;
   }
 
   // TODO - verify that using the managed vs unmanaged does not matter.
   // They both use the same MemoryTracker, and this call just re-routes
   // to it.
   if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(args.pixels_size)) {
-    ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, "glTexImage2D",
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, function_name,
                             "out of memory");
     return false;
   }
 
   // Write the TextureReference since this is valid.
   *texture_ref = local_texture_ref;
   return true;
 }
 
 void TextureManager::ValidateAndDoTexImage2D(
@@ skipping 77 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu