gpu: Support ES3 msaa and depth/stencil formats

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 <set>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 82 matching lines @@
   if (workarounds->max_cube_map_texture_size_limit_1024)
     workarounds->max_cube_map_texture_size = 1024;
   if (workarounds->max_cube_map_texture_size_limit_512)
     workarounds->max_cube_map_texture_size = 512;
 }
 
 }  // anonymous namespace.
 
 FeatureInfo::FeatureFlags::FeatureFlags()
     : chromium_framebuffer_multisample(false),
+      core_framebuffer_multisample(false),
       multisampled_render_to_texture(false),
       use_img_for_multisampled_render_to_texture(false),
       oes_standard_derivatives(false),
       oes_egl_image_external(false),
       oes_depth24(false),
+      packed_depth24_stencil8(false),
       npot_ok(false),
       enable_texture_float_linear(false),
       enable_texture_half_float_linear(false),
       chromium_stream_texture(false),
       angle_translated_shader_source(false),
       angle_pack_reverse_row_order(false),
       arb_texture_rectangle(false),
       angle_instanced_arrays(false),
       occlusion_query_boolean(false),
       use_arb_occlusion_query2_for_occlusion_query_boolean(false),
@@ skipping 80 matching lines @@
   return true;
 }
 
 void FeatureInfo::InitializeFeatures() {
   // Figure out what extensions to turn on.
   StringSet extensions(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
 
   bool npot_ok = false;
 
+  bool is_es3 = false;
+  const char* str = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+  if (str) {
+    std::string lstr(StringToLowerASCII(std::string(str)));
+    is_es3 = (lstr.substr(0, 12) == "opengl es 3.");

[Ken Russell (switch to Gerrit), 2013/11/14 01:18:37]

Is this going to scale well to some hypothetical OpenGL ES 4.0? Is there a
better way to do this feature detection?

[Sami, 2013/11/14 15:48:53]

You could also check for glGetIntegerv({MAJOR_VERSION,MINOR_VERSION}) --
although that won't distinguish between ES vs. desktop but I'm not sure if it
makes a difference here. Note that this query isn't supported by ES 2.0 though
:)

+  }
+
   AddExtensionString("GL_ANGLE_translated_shader_source");
   AddExtensionString("GL_CHROMIUM_async_pixel_transfers");
   AddExtensionString("GL_CHROMIUM_bind_uniform_location");
   AddExtensionString("GL_CHROMIUM_command_buffer_query");
   AddExtensionString("GL_CHROMIUM_command_buffer_latency_query");
   AddExtensionString("GL_CHROMIUM_copy_texture");
   AddExtensionString("GL_CHROMIUM_discard_backbuffer");
   AddExtensionString("GL_CHROMIUM_get_error_query");
   AddExtensionString("GL_CHROMIUM_lose_context");
   AddExtensionString("GL_CHROMIUM_pixel_transfer_buffer_object");
@@ skipping 87 matching lines @@
   //
   // Therefore we made up GL_GOOGLE_depth_texture / GL_CHROMIUM_depth_texture.
   //
   // GL_GOOGLE_depth_texture is legacy. As we exposed it into NaCl we can't
   // get rid of it.
   //
   bool enable_depth_texture = false;
   if (!workarounds_.disable_depth_texture &&
       (extensions.Contains("GL_ARB_depth_texture") ||
        extensions.Contains("GL_OES_depth_texture") ||
-       extensions.Contains("GL_ANGLE_depth_texture"))) {
+       extensions.Contains("GL_ANGLE_depth_texture") || is_es3)) {
     enable_depth_texture = true;
   }
 
   if (enable_depth_texture) {
     AddExtensionString("GL_CHROMIUM_depth_texture");
     AddExtensionString("GL_GOOGLE_depth_texture");
     texture_format_validators_[GL_DEPTH_COMPONENT].AddValue(GL_UNSIGNED_SHORT);
     texture_format_validators_[GL_DEPTH_COMPONENT].AddValue(GL_UNSIGNED_INT);
     validators_.texture_internal_format.AddValue(GL_DEPTH_COMPONENT);
     validators_.texture_format.AddValue(GL_DEPTH_COMPONENT);
     validators_.pixel_type.AddValue(GL_UNSIGNED_SHORT);
     validators_.pixel_type.AddValue(GL_UNSIGNED_INT);
   }
 
   if (extensions.Contains("GL_EXT_packed_depth_stencil") ||
-      extensions.Contains("GL_OES_packed_depth_stencil")) {
+      extensions.Contains("GL_OES_packed_depth_stencil") || is_es3) {
     AddExtensionString("GL_OES_packed_depth_stencil");
+    feature_flags_.packed_depth24_stencil8 = true;
     if (enable_depth_texture) {
-      texture_format_validators_[GL_DEPTH_STENCIL].AddValue(
-          GL_UNSIGNED_INT_24_8);
+      texture_format_validators_[GL_DEPTH_STENCIL]
+          .AddValue(GL_UNSIGNED_INT_24_8);
       validators_.texture_internal_format.AddValue(GL_DEPTH_STENCIL);
       validators_.texture_format.AddValue(GL_DEPTH_STENCIL);
       validators_.pixel_type.AddValue(GL_UNSIGNED_INT_24_8);
     }
     validators_.render_buffer_format.AddValue(GL_DEPTH24_STENCIL8);
   }
 
   if (extensions.Contains("GL_OES_vertex_array_object") ||
       extensions.Contains("GL_ARB_vertex_array_object") ||
       extensions.Contains("GL_APPLE_vertex_array_object")) {
@@ skipping 117 matching lines @@
     texture_format_validators_[GL_LUMINANCE_ALPHA].AddValue(GL_HALF_FLOAT_OES);
     validators_.pixel_type.AddValue(GL_HALF_FLOAT_OES);
     validators_.read_pixel_type.AddValue(GL_HALF_FLOAT_OES);
     AddExtensionString("GL_OES_texture_half_float");
     if (enable_texture_half_float_linear) {
       AddExtensionString("GL_OES_texture_half_float_linear");
     }
   }
 
   // Check for multisample support
-  if (!disallowed_features_.multisampling) {
+  if (!disallowed_features_.multisampling &&
+      !workarounds_.disable_framebuffer_multisample) {
     bool ext_has_multisample =
-        extensions.Contains("GL_EXT_framebuffer_multisample");
+        extensions.Contains("GL_EXT_framebuffer_multisample") || is_es3;
     if (!workarounds_.disable_angle_framebuffer_multisample) {
       ext_has_multisample |=
          extensions.Contains("GL_ANGLE_framebuffer_multisample");
     }
+    feature_flags_.core_framebuffer_multisample = is_es3;
     if (ext_has_multisample) {
       feature_flags_.chromium_framebuffer_multisample = true;
       validators_.frame_buffer_target.AddValue(GL_READ_FRAMEBUFFER_EXT);
       validators_.frame_buffer_target.AddValue(GL_DRAW_FRAMEBUFFER_EXT);
       validators_.g_l_state.AddValue(GL_READ_FRAMEBUFFER_BINDING_EXT);
       validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
       validators_.render_buffer_parameter.AddValue(GL_RENDERBUFFER_SAMPLES_EXT);
       AddExtensionString("GL_CHROMIUM_framebuffer_multisample");
     } else {
       if (extensions.Contains("GL_EXT_multisampled_render_to_texture")) {
         feature_flags_.multisampled_render_to_texture = true;
       } else if (extensions.Contains("GL_IMG_multisampled_render_to_texture")) {
         feature_flags_.multisampled_render_to_texture = true;
         feature_flags_.use_img_for_multisampled_render_to_texture = true;
       }
       if (feature_flags_.multisampled_render_to_texture) {
         validators_.render_buffer_parameter.AddValue(
             GL_RENDERBUFFER_SAMPLES_EXT);
         validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
         validators_.frame_buffer_parameter.AddValue(
             GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT);
         AddExtensionString("GL_EXT_multisampled_render_to_texture");
       }
     }
   }
 
-  if (extensions.Contains("GL_OES_depth24") || gfx::HasDesktopGLFeatures()) {
+  if (extensions.Contains("GL_OES_depth24") || gfx::HasDesktopGLFeatures() ||
+      is_es3) {
     AddExtensionString("GL_OES_depth24");
     feature_flags_.oes_depth24 = true;
     validators_.render_buffer_format.AddValue(GL_DEPTH_COMPONENT24);
   }
 
   if (!workarounds_.disable_oes_standard_derivatives &&
       (extensions.Contains("GL_OES_standard_derivatives") ||
        gfx::HasDesktopGLFeatures())) {
     AddExtensionString("GL_OES_standard_derivatives");
     feature_flags_.oes_standard_derivatives = true;
@@ skipping 139 matching lines @@
   }
 
   if (extensions.Contains("GL_EXT_frag_depth") || gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_EXT_frag_depth");
     feature_flags_.ext_frag_depth = true;
   }
 
   if (!disallowed_features_.swap_buffer_complete_callback)
     AddExtensionString("GL_CHROMIUM_swapbuffers_complete_callback");
 
-  bool is_es3 = false;
-  const char* str = reinterpret_cast<const char*>(glGetString(GL_VERSION));
-  if (str) {
-    std::string lstr(StringToLowerASCII(std::string(str)));
-    is_es3 = (lstr.substr(0, 12) == "opengl es 3.");
-  }
-
   bool ui_gl_fence_works = extensions.Contains("GL_NV_fence") ||
                            extensions.Contains("GL_ARB_sync") ||
                            extensions.Contains("EGL_KHR_fence_sync");
 
   feature_flags_.map_buffer_range =
       is_es3 || extensions.Contains("GL_ARB_map_buffer_range");
 
   // Really it's part of core OpenGL 2.1 and up, but let's assume the
   // extension is still advertised.
   bool has_pixel_buffers =
@@ skipping 23 matching lines @@
   if (extensions_.find(str) == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu