Add GL_EXT_color_buffer_half_float support

gpu/command_buffer/service/feature_info.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/feature_info.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 215 matching lines @@
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_R16F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_RG16F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGBA16F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_R32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_RG32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGBA32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_R11F_G11F_B10F);
-  feature_flags_.enable_color_buffer_float = true;
+}
+
+void FeatureInfo::EnableEXTColorBufferHalfFloat() {
+  if (!feature_flags_.enable_color_buffer_half_float)
+    return;
+  AddExtensionString("GL_EXT_color_buffer_half_float");
+  validators_.render_buffer_format.AddValue(GL_R16F);
+  validators_.render_buffer_format.AddValue(GL_RG16F);
+  validators_.render_buffer_format.AddValue(GL_RGB16F);
+  validators_.render_buffer_format.AddValue(GL_RGBA16F);
+  validators_.texture_sized_color_renderable_internal_format.AddValue(GL_R16F);
+  validators_.texture_sized_color_renderable_internal_format.AddValue(GL_RG16F);
+  validators_.texture_sized_color_renderable_internal_format.AddValue(
+      GL_RGB16F);
+  validators_.texture_sized_color_renderable_internal_format.AddValue(
+      GL_RGBA16F);
 }
 
 void FeatureInfo::EnableCHROMIUMColorBufferFloatRGBA() {
   if (!feature_flags_.chromium_color_buffer_float_rgba)
     return;
   validators_.texture_internal_format.AddValue(GL_RGBA32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGBA32F);
   AddExtensionString("GL_CHROMIUM_color_buffer_float_rgba");
 }
@@ skipping 478 matching lines @@
     feature_flags_.npot_ok = true;
   }
 
   // Check if we should allow GL_OES_texture_float, GL_OES_texture_half_float,
   // GL_OES_texture_float_linear, GL_OES_texture_half_float_linear
   bool enable_texture_float = false;
   bool enable_texture_float_linear = false;
   bool enable_texture_half_float = false;
   bool enable_texture_half_float_linear = false;
   bool enable_ext_color_buffer_float = false;
+  bool enable_ext_color_buffer_half_float = false;
 
   bool may_enable_chromium_color_buffer_float = false;
 
-  // This extension allows a variety of floating point formats to be
+  // These extensions allow a variety of floating point formats to be
   // rendered to via framebuffer objects.
-  if (extensions.Contains("GL_EXT_color_buffer_float")) {
+  if (extensions.Contains("GL_EXT_color_buffer_float"))
     enable_ext_color_buffer_float = true;
-  }
+  if (extensions.Contains("GL_EXT_color_buffer_half_float"))
+    enable_ext_color_buffer_half_float = true;
 
   if (extensions.Contains("GL_ARB_texture_float") ||
       gl_version_info_->is_desktop_core_profile) {
     enable_texture_float = true;
     enable_texture_float_linear = true;
     enable_texture_half_float = true;
     enable_texture_half_float_linear = true;
     may_enable_chromium_color_buffer_float = true;
   } else {
     // GLES3 adds support for Float type by default but it doesn't support all
@@ skipping 75 matching lines @@
                               GL_TEXTURE_2D, tex_id, 0);
     GLenum status_rgba = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, width, 0, GL_RGB,
                  GL_FLOAT, NULL);
     GLenum status_rgb = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 
     // For desktop systems, check to see if we support rendering to the full
     // range of formats supported by EXT_color_buffer_float
     if (status_rgba == GL_FRAMEBUFFER_COMPLETE && enable_es3) {
       bool full_float_support = true;
-
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_R16F, width, width, 0, GL_RED,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, width, width, 0, GL_RG,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, width, 0, GL_RGBA,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, width, width, 0, GL_RED,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, width, width, 0, GL_RG,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-      glTexImage2D(GL_TEXTURE_2D, 0, GL_R11F_G11F_B10F, width, width, 0, GL_RGB,
-          GL_FLOAT, NULL);
-      full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
-          GL_FRAMEBUFFER_COMPLETE;
-
+      GLenum internal_formats[] = {
+          GL_R16F, GL_RG16F, GL_RGBA16F, GL_R32F, GL_RG32F, GL_R11F_G11F_B10F,
+      };
+      GLenum formats[] = {
+          GL_RED, GL_RG, GL_RGBA, GL_RED, GL_RG, GL_RGB,
+      };
+      DCHECK_EQ(arraysize(internal_formats), arraysize(formats));
+      for (size_t i = 0; i < arraysize(formats); ++i) {
+        glTexImage2D(GL_TEXTURE_2D, 0, internal_formats[i], width, width, 0,
+                     formats[i], GL_FLOAT, NULL);
+        full_float_support &= glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
+                              GL_FRAMEBUFFER_COMPLETE;
+      }
       enable_ext_color_buffer_float = full_float_support;
     }
+    // Likewise for EXT_color_buffer_half_float on ES2 contexts.
+    if (IsWebGL1OrES2Context() &&
+        !feature_flags_.enable_color_buffer_half_float) {
+      bool full_half_float_support = true;
+      GLenum internal_formats[] = {
+          GL_R16F, GL_RG16F, GL_RGB16F, GL_RGBA16F,
+      };
+      GLenum formats[] = {
+          GL_RED, GL_RG, GL_RGB, GL_RGBA,
+      };
+      DCHECK_EQ(arraysize(internal_formats), arraysize(formats));
+      for (size_t i = 0; i < arraysize(formats); ++i) {
+        glTexImage2D(GL_TEXTURE_2D, 0, internal_formats[i], width, width, 0,
+                     formats[i], GL_FLOAT, NULL);
+        full_half_float_support &=
+            glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) ==
+            GL_FRAMEBUFFER_COMPLETE;
+      }
+      enable_ext_color_buffer_half_float = full_half_float_support;
+    }
 
     glDeleteFramebuffersEXT(1, &fb_id);
     glDeleteTextures(1, &tex_id);
 
     glBindFramebufferEXT(GL_FRAMEBUFFER, static_cast<GLuint>(fb_binding));
     glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(tex_binding));
 
     DCHECK(glGetError() == GL_NO_ERROR);
 
     if (status_rgba == GL_FRAMEBUFFER_COMPLETE) {
       feature_flags_.chromium_color_buffer_float_rgba = true;
       if (!disallowed_features_.chromium_color_buffer_float_rgba)
         EnableCHROMIUMColorBufferFloatRGBA();
     }
     if (status_rgb == GL_FRAMEBUFFER_COMPLETE) {
       feature_flags_.chromium_color_buffer_float_rgb = true;
       if (!disallowed_features_.chromium_color_buffer_float_rgb)
         EnableCHROMIUMColorBufferFloatRGB();
     }
   }
 
   // Enable the GL_EXT_color_buffer_float extension for WebGL 2.0
   if (enable_ext_color_buffer_float && enable_es3) {
     ext_color_buffer_float_available_ = true;
     if (!disallowed_features_.ext_color_buffer_float)
       EnableEXTColorBufferFloat();
   }
 
+  // Enable GL_EXT_color_buffer_half_float if we have found the capability.
+  if (enable_ext_color_buffer_half_float &&
+      !disallowed_features_.ext_color_buffer_half_float) {
+    feature_flags_.enable_color_buffer_half_float = true;
+    EnableEXTColorBufferHalfFloat();
+  }
+
   // Check for multisample support
   if (!workarounds_.disable_chromium_framebuffer_multisample) {
     bool ext_has_multisample =
         extensions.Contains("GL_EXT_framebuffer_multisample") ||
         gl_version_info_->is_es3 ||
         gl_version_info_->is_desktop_core_profile;
     if (gl_version_info_->is_angle) {
       feature_flags_.angle_framebuffer_multisample =
           extensions.Contains("GL_ANGLE_framebuffer_multisample");
       ext_has_multisample |= feature_flags_.angle_framebuffer_multisample;
@@ skipping 624 matching lines @@
   if (pos == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu