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

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 62 matching lines @@
 extern uint64 CityHash64(const char*, size_t);
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 static const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
 static const char kEXTFragDepthExtension[] = "GL_EXT_frag_depth";
 static const char kEXTDrawBuffersExtension[] = "GL_EXT_draw_buffers";
+static const char kCHROMIUMColorBufferFloatExtension[] =
+    "GL_CHROMIUM_color_buffer_float";
 
 #if !defined(ANGLE_SH_VERSION) || ANGLE_SH_VERSION < 108
 khronos_uint64_t CityHashForAngle(const char* name, unsigned int len) {
   return static_cast<khronos_uint64_t>(
       CityHash64(name, static_cast<size_t>(len)));
 }
 #endif
 
 static bool PrecisionMeetsSpecForHighpFloat(GLint rangeMin,
                                             GLint rangeMax,
@@ skipping 1568 matching lines @@
 
   // These flags are used to override the state of the shared feature_info_
   // member.  Because the same FeatureInfo instance may be shared among many
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
   bool force_webgl_glsl_validation_;
   bool derivatives_explicitly_enabled_;
   bool frag_depth_explicitly_enabled_;
   bool draw_buffers_explicitly_enabled_;
+  bool chromium_color_buffer_float_explicitly_enabled_;

[piman, 2014/02/07 00:43:10]

I don't think we need this. Since we decided that WebGL assumes the extension is
there (but allows it to fail), and the other clients would test for the
extension and only use it if it's there, we shouldn't need to explicitly
EnableFeatureCHROMIUM to use it.

EnableFeatureCHROMIUM is there essentially to change the validation, and really
only for glsl. This doesn't have any glsl impact, so we don't need to do this
dance.

[oetuaho-nv, 2014/02/07 09:26:58]

Okay. I just got the idea from earlier reviews that this should not be enabled
by default, but making it so will make things easier.

 
   bool compile_shader_always_succeeds_;
 
   // Log extra info.
   bool service_logging_;
 
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
@@ skipping 479 matching lines @@
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       frame_number_(0),
       has_robustness_extension_(false),
       reset_status_(GL_NO_ERROR),
       reset_by_robustness_extension_(false),
       force_webgl_glsl_validation_(false),
       derivatives_explicitly_enabled_(false),
       frag_depth_explicitly_enabled_(false),
       draw_buffers_explicitly_enabled_(false),
+      chromium_color_buffer_float_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
       service_logging_(CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGPUServiceLoggingGPU)),
       viewport_max_width_(0),
       viewport_max_height_(0),
       texture_state_(group_->feature_info()
                          ->workarounds()
                          .texsubimage2d_faster_than_teximage2d),
       validation_texture_(0),
       validation_fbo_multisample_(0),
@@ skipping 772 matching lines @@
       backbuffer_needs_clear_bits_ = 0;
       RestoreClearState();
     }
     return true;
   }
 
   if (framebuffer_manager()->IsComplete(framebuffer)) {
     return true;
   }
 
-  GLenum completeness = framebuffer->IsPossiblyComplete();
+  GLenum completeness = framebuffer->IsPossiblyComplete(
+      chromium_color_buffer_float_explicitly_enabled_);
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_FRAMEBUFFER_OPERATION, func_name, "framebuffer incomplete");
     return false;
   }
 
   // Are all the attachments cleared?
   if (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
       texture_manager()->HaveUnclearedMips()) {
     if (!framebuffer->IsCleared()) {
@@ skipping 1915 matching lines @@
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
-  GLenum completeness = framebuffer->IsPossiblyComplete();
+  GLenum completeness = framebuffer->IsPossiblyComplete(
+      chromium_color_buffer_float_explicitly_enabled_);
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     return completeness;
   }
   return framebuffer->GetStatus(texture_manager(), target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   DoFramebufferTexture2DCommon(
@@ skipping 2684 matching lines @@
           if (!draw_buffers_explicitly_enabled_) {
             size_t offset = extensions.find(kEXTDrawBuffersExtension);
             if (std::string::npos != offset) {
               extensions.replace(offset, arraysize(kEXTDrawBuffersExtension),
                                  std::string());
             }
           }
         } else {
           extensions = feature_info_->extensions().c_str();
         }
+        // Strip out CHROMIUM_color_buffer_float for all contexts that have
+        // not enabled it to emulate GLES2 more closely.
+        if (!chromium_color_buffer_float_explicitly_enabled_) {
+          size_t offset = extensions.find(
+              kCHROMIUMColorBufferFloatExtension);
+          if (std::string::npos != offset) {
+            extensions.replace(offset,
+                               arraysize(kCHROMIUMColorBufferFloatExtension),
+                               std::string());
+          }
+        }
         std::string surface_extensions = surface_->GetExtensions();
         if (!surface_extensions.empty())
           extensions += " " + surface_extensions;
         str = extensions.c_str();
       }
       break;
     default:
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
@@ skipping 1446 matching lines @@
     uint32 immediate_data_size, const cmds::RequestExtensionCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
   }
 
+  bool desire_chromium_color_buffer_float =
+      feature_str.find("GL_CHROMIUM_color_buffer_float") != std::string::npos;
+
+  if (desire_chromium_color_buffer_float &&
+      feature_info_->feature_flags().chromium_color_buffer_float) {
+    chromium_color_buffer_float_explicitly_enabled_ = true;
+  }
+
   bool desire_webgl_glsl_validation =
       feature_str.find("GL_CHROMIUM_webglsl") != std::string::npos;
   bool desire_standard_derivatives = false;
   bool desire_frag_depth = false;
   bool desire_draw_buffers = false;
   if (force_webgl_glsl_validation_) {
     desire_standard_derivatives =
         feature_str.find("GL_OES_standard_derivatives") != std::string::npos;
     desire_frag_depth =
         feature_str.find("GL_EXT_frag_depth") != std::string::npos;
@@ skipping 1437 matching lines @@
   DoDidUseTexImageIfNeeded(texture, texture->target());
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu