Extend more runtime envs for generateMipmap srgb emulation

gpu/command_buffer/service/gles2_cmd_srgb_converter.cc

 // Copyright (c) 2016 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_srgb_converter.h"
 
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace {
@@ skipping 23 matching lines @@
 
 
 
 void SRGBConverter::InitializeSRGBConverterProgram() {
   if (srgb_converter_program_) {
     return;
   }
 
   srgb_converter_program_ = glCreateProgram();
 
+  const char* kShaderPrecisionPreamble =
+      "#ifdef GL_ES\n"
+      "precision mediump float;\n"
+      "#define TexCoordPrecision mediump\n"
+      "#else\n"
+      "#define TexCoordPrecision\n"
+      "#endif\n";
+
+  std::string vs_source;
+  if (feature_info_->gl_version_info().is_es) {
+    if (feature_info_->gl_version_info().is_es3) {
+      vs_source += "#version 300 es\n";
+      vs_source +=
+          "#define ATTRIBUTE in\n"
+          "#define VARYING out\n";
+    } else {
+      vs_source +=
+          "#define ATTRIBUTE attribute\n"
+          "#define VARYING varying\n";
+    }
+  } else {
+    vs_source += "#version 150\n";
+    vs_source +=
+        "#define ATTRIBUTE in\n"
+        "#define VARYING out\n";
+  }
+
+  vs_source += kShaderPrecisionPreamble;
+
+  // TODO(yizhou): gles 2.0 does not support gl_VertexID.
   // Compile the vertex shader
-  const char* vs_source =
-      "#version 150\n"
-      "out vec2 v_texcoord;\n"
+  vs_source +=
+      "VARYING TexCoordPrecision vec2 v_texcoord;\n"
       "\n"
       "void main()\n"
       "{\n"
       "    const vec2 quad_positions[6] = vec2[6]\n"
       "    (\n"
       "        vec2(0.0f, 0.0f),\n"
       "        vec2(0.0f, 1.0f),\n"
       "        vec2(1.0f, 0.0f),\n"
       "\n"
       "        vec2(0.0f, 1.0f),\n"
       "        vec2(1.0f, 0.0f),\n"
       "        vec2(1.0f, 1.0f)\n"
       "    );\n"
       "\n"
       "    vec2 xy = vec2((quad_positions[gl_VertexID] * 2.0) - 1.0);\n"
       "    gl_Position = vec4(xy, 0.0, 1.0);\n"
       "    v_texcoord = quad_positions[gl_VertexID];\n"
       "}\n";
   GLuint vs = glCreateShader(GL_VERTEX_SHADER);
-  CompileShader(vs, vs_source);
+  CompileShader(vs, vs_source.c_str());
   glAttachShader(srgb_converter_program_, vs);
   glDeleteShader(vs);
 
   // Compile the fragment shader
 
   // Sampling texels from a srgb texture to a linear image, it will convert
   // the srgb color space to linear color space automatically as a part of
   // filtering. See the section <sRGB Texture Color Conversion> in GLES and
   // OpenGL spec. So during decoding, we don't need to use the equation to
   // explicitly decode srgb to linear in fragment shader.
   // Drawing to a srgb image, it will convert linear to srgb automatically.
   // See the section <sRGB Conversion> in GLES and OpenGL spec. So during
   // encoding, we don't need to use the equation to explicitly encode linear
   // to srgb in fragment shader.
   // As a result, we just use a simple fragment shader to do srgb conversion.
-  const char* fs_source =
-      "#version 150\n"
-      "uniform sampler2D u_source_texture;\n"
-      "in vec2 v_texcoord;\n"
-      "out vec4 output_color;\n"
+  std::string fs_source;
+  if (feature_info_->gl_version_info().is_es) {
+    if (feature_info_->gl_version_info().is_es3) {
+      fs_source += "#version 300 es\n";
+    }
+  } else {
+    fs_source += "#version 150\n";
+  }
+
+  fs_source += kShaderPrecisionPreamble;
+
+  if (feature_info_->gl_version_info().is_es) {
+    if (feature_info_->gl_version_info().is_es3) {
+      fs_source +=
+          "#define VARYING in\n"
+          "out vec4 frag_color;\n"
+          "#define FRAGCOLOR frag_color\n"
+          "#define TextureLookup texture\n";
+    } else {
+      fs_source +=
+          "#define VARYING varying\n"
+          "#define FRAGCOLOR gl_FragColor\n"
+          "#define TextureLookup texture2D\n";
+    }
+  } else {
+    fs_source +=
+        "#define VARYING in\n"
+        "out vec4 frag_color;\n"
+        "#define FRAGCOLOR frag_color\n"
+        "#define TextureLookup texture\n";
+  }
+
+  fs_source +=
+      "uniform mediump sampler2D u_source_texture;\n"
+      "VARYING TexCoordPrecision vec2 v_texcoord;\n"
       "\n"
       "void main()\n"
       "{\n"
-      "    vec4 c = texture(u_source_texture, v_texcoord);\n"
-      "    output_color = c;\n"
+      "    vec4 c = TextureLookup(u_source_texture, v_texcoord);\n"
+      "    FRAGCOLOR = c;\n"
       "}\n";
 
   GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
-  CompileShader(fs, fs_source);
+  CompileShader(fs, fs_source.c_str());
   glAttachShader(srgb_converter_program_, fs);
   glDeleteShader(fs);
 
   glLinkProgram(srgb_converter_program_);
 #ifndef NDEBUG
   GLint linked = 0;
   glGetProgramiv(srgb_converter_program_, GL_LINK_STATUS, &linked);
   if (!linked) {
     DLOG(ERROR) << "BlitFramebuffer: program link failure.";
   }
@@ skipping 129 matching lines @@
     xoffset = c.x() - x;
     yoffset = c.y() - y;
     glCopyTexImage2D(GL_TEXTURE_2D, 0, src_framebuffer_internal_format,
                      c.x(), c.y(), c.width(), c.height(), 0);
 
     // Make a temporary linear texture as the 2nd texture, where we
     // render the converted (srgb to linear) result to.
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
     glBindTexture(GL_TEXTURE_2D, srgb_converter_textures_[1]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F,
-                 c.width(), c.height(),
-                 0, GL_RGBA, GL_FLOAT, nullptr);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, c.width(), c.height(), 0,
+                 GL_RGBA, GL_FLOAT, nullptr);
     glBindFramebufferEXT(GL_FRAMEBUFFER, srgb_decoder_fbo_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D, srgb_converter_textures_[1], 0);
 
     // Sampling from the 1st texture(srgb) and drawing to the
     // 2nd texture(linear),
     glUseProgram(srgb_converter_program_);
     glViewport(0, 0, width_read, height_read);
 
     glBindTexture(GL_TEXTURE_2D, srgb_converter_textures_[0]);
@@ skipping 11 matching lines @@
   // during bliting. Note that the src and dst coordinates may be reversed.
   GLuint width_draw = 0, height_draw = 0;
   if (encode) {
     glBindTexture(GL_TEXTURE_2D, srgb_converter_textures_[0]);
 
     width_draw = dstX1 > dstX0 ? dstX1 - dstX0 : dstX0 - dstX1;
     height_draw = dstY1 > dstY0 ? dstY1 - dstY0 : dstY0 - dstY1;
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
     glTexImage2D(
         GL_TEXTURE_2D, 0, decode ? GL_RGBA32F : src_framebuffer_internal_format,
-        width_draw, height_draw, 0,
-        decode ? GL_RGBA : src_framebuffer_format,
-        decode ? GL_FLOAT : src_framebuffer_type,
-        nullptr);
+        width_draw, height_draw, 0, decode ? GL_RGBA : src_framebuffer_format,
+        decode ? GL_FLOAT : src_framebuffer_type, nullptr);
 
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, srgb_encoder_fbo_);
     glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D, srgb_converter_textures_[0], 0);
   } else {
     // Set approriate draw framebuffer if encoding is skipped.
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, dst_framebuffer);
 
     if (enable_scissor_test) {
       glEnable(GL_SCISSOR_TEST);
@@ skipping 136 matching lines @@
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
   decoder->RestoreTextureState(tex->service_id());
 }
 
 }  // namespace gles2.
 }  // namespace gpu