Query the GL limits for the passthrough command buffer.

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 87 matching lines @@
 const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
 const char kEXTFragDepthExtension[] = "GL_EXT_frag_depth";
 const char kEXTDrawBuffersExtension[] = "GL_EXT_draw_buffers";
 const char kEXTShaderTextureLodExtension[] = "GL_EXT_shader_texture_lod";
 
 const GLfloat kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
                                      0.0f, 1.0f, 0.0f, 0.0f,
                                      0.0f, 0.0f, 1.0f, 0.0f,
                                      0.0f, 0.0f, 0.0f, 1.0f};
 
-bool PrecisionMeetsSpecForHighpFloat(GLint rangeMin,
-                                            GLint rangeMax,
-                                            GLint precision) {
-  return (rangeMin >= 62) && (rangeMax >= 62) && (precision >= 16);
-}
-
-void GetShaderPrecisionFormatImpl(const gl::GLVersionInfo& gl_version_info,
-                                  GLenum shader_type,
-                                  GLenum precision_type,
-                                  GLint* range,
-                                  GLint* precision) {
-  switch (precision_type) {
-    case GL_LOW_INT:
-    case GL_MEDIUM_INT:
-    case GL_HIGH_INT:
-      // These values are for a 32-bit twos-complement integer format.
-      range[0] = 31;
-      range[1] = 30;
-      *precision = 0;
-      break;
-    case GL_LOW_FLOAT:
-    case GL_MEDIUM_FLOAT:
-    case GL_HIGH_FLOAT:
-      // These values are for an IEEE single-precision floating-point format.
-      range[0] = 127;
-      range[1] = 127;
-      *precision = 23;
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-
-  if (gl_version_info.is_es) {
-    // This function is sometimes defined even though it's really just
-    // a stub, so we need to set range and precision as if it weren't
-    // defined before calling it.
-    // On Mac OS with some GPUs, calling this generates a
-    // GL_INVALID_OPERATION error. Avoid calling it on non-GLES2
-    // platforms.
-    glGetShaderPrecisionFormat(shader_type, precision_type,
-                               range, precision);
-
-    // TODO(brianderson): Make the following official workarounds.
-
-    // Some drivers have bugs where they report the ranges as a negative number.
-    // Taking the absolute value here shouldn't hurt because negative numbers
-    // aren't expected anyway.
-    range[0] = abs(range[0]);
-    range[1] = abs(range[1]);
-
-    // If the driver reports a precision for highp float that isn't actually
-    // highp, don't pretend like it's supported because shader compilation will
-    // fail anyway.
-    if (precision_type == GL_HIGH_FLOAT &&
-        !PrecisionMeetsSpecForHighpFloat(range[0], range[1], *precision)) {
-      range[0] = 0;
-      range[1] = 0;
-      *precision = 0;
-    }
-  }
-}
-
 gfx::OverlayTransform GetGFXOverlayTransform(GLenum plane_transform) {
   switch (plane_transform) {
     case GL_OVERLAY_TRANSFORM_NONE_CHROMIUM:
       return gfx::OVERLAY_TRANSFORM_NONE;
     case GL_OVERLAY_TRANSFORM_FLIP_HORIZONTAL_CHROMIUM:
       return gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
     case GL_OVERLAY_TRANSFORM_FLIP_VERTICAL_CHROMIUM:
       return gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL;
     case GL_OVERLAY_TRANSFORM_ROTATE_90_CHROMIUM:
       return gfx::OVERLAY_TRANSFORM_ROTATE_90;
@@ skipping 3325 matching lines @@
 
 Capabilities GLES2DecoderImpl::GetCapabilities() {
   DCHECK(initialized());
   Capabilities caps;
   const gl::GLVersionInfo& version_info = gl_version_info();
   caps.VisitPrecisions([&version_info](
       GLenum shader, GLenum type,
       Capabilities::ShaderPrecision* shader_precision) {
     GLint range[2] = {0, 0};
     GLint precision = 0;
-    GetShaderPrecisionFormatImpl(version_info, shader, type, range,
-                                 &precision);
+    QueryShaderPrecisionFormat(version_info, shader, type, range, &precision);
     shader_precision->min_range = range[0];
     shader_precision->max_range = range[1];
     shader_precision->precision = precision;
   });
   DoGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                 &caps.max_combined_texture_image_units);
   DoGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &caps.max_cube_map_texture_size);
   DoGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS,
                 &caps.max_fragment_uniform_vectors);
   DoGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &caps.max_renderbuffer_size);
@@ skipping 171 matching lines @@
     resources.MaxVertexOutputVectors =
         group_->max_vertex_output_components() / 4;
     resources.MaxFragmentInputVectors =
         group_->max_fragment_input_components() / 4;
     resources.MaxProgramTexelOffset = group_->max_program_texel_offset();
     resources.MinProgramTexelOffset = group_->min_program_texel_offset();
   }
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
-  GetShaderPrecisionFormatImpl(gl_version_info(), GL_FRAGMENT_SHADER,
-                               GL_HIGH_FLOAT, range, &precision);
+  QueryShaderPrecisionFormat(gl_version_info(), GL_FRAGMENT_SHADER,
+                             GL_HIGH_FLOAT, range, &precision);
   resources.FragmentPrecisionHigh =
       PrecisionMeetsSpecForHighpFloat(range[0], range[1], precision);
 
   ShShaderSpec shader_spec;
   switch (feature_info_->context_type()) {
     case CONTEXT_TYPE_WEBGL1:
       shader_spec = SH_WEBGL_SPEC;
       resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
       resources.EXT_frag_depth = frag_depth_explicitly_enabled_;
       resources.EXT_draw_buffers = draw_buffers_explicitly_enabled_;
@@ skipping 10110 matching lines @@
   if (!validators_->shader_precision.IsValid(precision_type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(
         "glGetShaderPrecisionFormat", precision_type, "precision_type");
     return error::kNoError;
   }
 
   result->success = 1;  // true
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
-  GetShaderPrecisionFormatImpl(gl_version_info(), shader_type, precision_type,
-                               range, &precision);
+  QueryShaderPrecisionFormat(gl_version_info(), shader_type, precision_type,
+                             range, &precision);
 
   result->min_range = range[0];
   result->max_range = range[1];
   result->precision = precision;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
     uint32_t immediate_data_size,
@@ skipping 4081 matching lines @@
 }
 
 // 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu