gpu, cmaa: optimize COMBINE_EDGES path to reduce fragment shader tasks

gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc

 // Copyright 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_apply_framebuffer_attachment_cmaa_intel.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_context.h"
@@ skipping 330 matching lines @@
   // Inputs
   //  g_screenTexture                     source_texture               tex0
   // Outputs
   //  gl_FragDepth                        mini4_edge_depth_texture_    fbo.depth
   //  out uvec4 outEdges                  mini4_edge_texture_          fbo.col
   //  image2D g_resultTextureFlt4Slot1    working_color_texture_       image1
   GLenum edge_format = supports_r8_image_ ? GL_R8 : GL_R32F;
 
   {
     glUseProgram(edges0_shader_);
-    glUniform1f(0, 1.0f);
-    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glUniform2f(0, 1.0f / width_, 1.0f / height_);
     glDepthMask(GL_TRUE);
     glDepthFunc(GL_ALWAYS);
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
     if (!is_gles31_compatible_) {
       glUniform1i(edges1_shader_result_texture_float4_slot1_, 1);
     }
     glBindImageTextureEXT(1, working_color_texture_, 0, GL_FALSE, 0,
                           GL_WRITE_ONLY, GL_RGBA8);
 
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, source_texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
     glDrawArrays(GL_TRIANGLES, 0, 3);
   }
 
   // Detect edges Pass 1 (finish the previous pass edge processing).
   // Do the culling of non-dominant local edges (leave mainly locally dominant
   // edges) and merge Right and Bottom edges into TopRightBottomLeft
 
   // Inputs
   //  g_src0Texture4Uint                  mini4_edge_texture_          tex1
   // Outputs
   //  image2D g_resultTexture             edge_texture_b               image0
   {
     glUseProgram(edges1_shader_);
-    glUniform1f(0, 0.0f);
-    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glUniform2f(0, 1.0f / width_, 1.0f / height_);
     glDepthMask(GL_FALSE);
     glDepthFunc(GL_LESS);
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
     if (!is_gles31_compatible_) {
       glUniform1i(edges1_shader_result_texture_, 0);
     }
     glBindImageTextureEXT(0, edge_texture_b, 0, GL_FALSE, 0, GL_WRITE_ONLY,
                           edge_format);
 
     glActiveTexture(GL_TEXTURE1);
     glBindTexture(GL_TEXTURE_2D, mini4_edge_texture_);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glDrawArrays(GL_TRIANGLES, 0, 3);
   }
 
   //  - Combine RightBottom (.xy) edges from previous pass into
-  //    RightBottomLeftTop (.xyzw) edges and output it into the mask (have to
-  //    fill in the whole buffer including empty ones for the line length
-  //    detection to work correctly).
+  //    RightBottomLeftTop (.xyzw) edges and output it into the mask.
   //  - On all pixels with any edge, input buffer into a temporary color buffer
   //    needed for correct blending in the next pass (other pixels not needed
   //    so not copied to avoid bandwidth use).
   //  - On all pixels with 2 or more edges output positive depth mask for the
   //    next pass.
 
   // Inputs
   //  g_src0TextureFlt                    edge_texture_b               tex1 //ps
   // Outputs
   //  image2D g_resultTextureSlot2        edge_texture_a               image2
   //  gl_FragDepth                        mini4_edge_texture_          fbo.depth
   {
     // Combine edges: each pixel will now contain info on all (top, right,
-    // bottom, left) edges; also create depth mask as above depth and mark
-    // potential Z sAND also copy source color data but only on edge pixels
+    // bottom, left) edges; also mark depth 1 value on all pixels with any edge
+    // and also copy source color data but only on edge pixels
     glUseProgram(edges_combine_shader_);
-    glUniform1f(0, 1.0f);
-    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glUniform2f(0, 1.0f / width_, 1.0f / height_);
     glDepthMask(GL_TRUE);
-    glDepthFunc(GL_ALWAYS);
+    glDepthFunc(GL_LESS);
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
     if (!is_gles31_compatible_) {
       glUniform1i(edges_combine_shader_result_texture_slot2_, 2);
     }
     glBindImageTextureEXT(2, edge_texture_a, 0, GL_FALSE, 0, GL_WRITE_ONLY,
                           edge_format);
 
     glActiveTexture(GL_TEXTURE1);
     glBindTexture(GL_TEXTURE_2D, edge_texture_b);
@@ skipping 13 matching lines @@
 
   // Inputs
   //  g_screenTexture                      working_color_texture_      tex0
   //  g_src0TextureFlt                     edge_texture_a              tex1 //ps
   //  sampled
   // Outputs
   //  g_resultTextureFlt4Slot1             dest_texture                image1
   //  gl_FragDepth                         mini4_edge_texture_         fbo.depth
   {
     glUseProgram(process_and_apply_shader_);
-    glUniform1f(0, 0.0f);
-    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glUniform2f(0, 1.0f / width_, 1.0f / height_);
     glDepthMask(GL_FALSE);
     glDepthFunc(GL_LESS);
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
     if (!is_gles31_compatible_) {
       glUniform1i(process_and_apply_shader_result_texture_float4_slot1_, 1);
     }
     glBindImageTextureEXT(1, dest_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY,
                           GL_RGBA8);
 
@@ skipping 213 matching lines @@
   }
 
   return shader;
 }
 
 /* clang-format off */
 // Shaders used in the CMAA algorithm.
 const char ApplyFramebufferAttachmentCMAAINTELResourceManager::vert_str_[] =
   SHADER(
     precision highp float;
-    layout(location = 0) uniform float g_Depth;
     // No input data.
     // Verts are autogenerated.
     //
     // vertexID 0,1,2 should generate
     // POS: (-1,-1), (+3,-1), (-1,+3)
     //
     // This generates a triangle that completely covers the -1->1 viewport
     //
     void main()
     {
        float x = -1.0 + float((gl_VertexID & 1) << 2);
        float y = -1.0 + float((gl_VertexID & 2) << 1);
-       gl_Position = vec4(x, y, g_Depth, 1.0);
+       gl_Position = vec4(x, y, 0.0, 1.0);
     }
   );
 
 const char ApplyFramebufferAttachmentCMAAINTELResourceManager::cmaa_frag_s1_[] =
   SHADER(
     precision highp float;
     precision highp int;
 
     \n#define SETTINGS_ALLOW_SHORT_Zs 1\n
     \n#define EDGE_DETECT_THRESHOLD 13.0f\n
     \n#define saturate(x) clamp((x), 0.0, 1.0)\n
 
-    // bind to location 0
-    layout(location = 0) uniform float g_Depth;
     // bind to a uniform buffer bind point 0
-    layout(location = 1) uniform vec2 g_OneOverScreenSize;
+    layout(location = 0) uniform vec2 g_OneOverScreenSize;
     \n#ifndef EDGE_DETECT_THRESHOLD\n
-    layout(location = 2) uniform float g_ColorThreshold;
+    layout(location = 1) uniform float g_ColorThreshold;
     \n#endif\n
 
     \n#ifdef SUPPORTS_USAMPLER2D\n
     \n#define USAMPLER usampler2D\n
     \n#define UVEC4 uvec4\n
     \n#define LOAD_UINT(arg) arg\n
     \n#define STORE_UVEC4(arg) arg\n
     \n#else\n
     \n#define USAMPLER sampler2D\n
     \n#define UVEC4 vec4\n
@@ skipping 421 matching lines @@
         et = saturate(et - threshold);
         ivec2 eti = ivec2(et * 15.0 + 0.99);
         outputEdges.w = uint(eti.x | (eti.y << 4));
 
         storeFlagPixel11 += et.x;
         storeFlagPixel11 += et.y;
         storeFlagPixel21 += et.x;
         storeFlagPixel12 += et.y;
       }
 
       gl_FragDepth = any(bvec4(outputEdges)) ? 1.0 : 0.0;

[dshwang, 2016/07/06 10:41:20]

gl_Depth is redudant.

 
       if (gl_FragDepth != 0.0) {
         if (storeFlagPixel00 != 0.0)
           imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 0),
                      pixel00);
         if (storeFlagPixel10 != 0.0)
           imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 0),
                      pixel10);
         if (storeFlagPixel20 != 0.0)
           imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(2, 0),
@@ skipping 247 matching lines @@
       imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(0, 1),
                  outEdge4Flt.zzzz);
       imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(1, 1),
                  outEdge4Flt.wwww);
 
       // uvec4 numberOfEdges4 = uvec4(bitCount(outEdge4));
       // gl_FragDepth =
       //     any(greaterThan(numberOfEdges4, uvec4(1))) ? 1.0 : 0.0;
 
       gl_FragDepth =
           any(greaterThan(outEdge4, uvec4(1))) ? 1.0 : 0.0;

[dshwang, 2016/07/06 10:41:20]

gl_Depth is redudant.

     }
     \n#endif\n  // COMBINE_EDGES
 
     \n#ifdef BLUR_EDGES\n
     layout(early_fragment_tests) in;
     void BlurEdges() {
       // Each |gl_FragCoord| updates 4 texels of the original texture, which are
       // 2x|gl_FragCoord| + (-1 or 0, -1 or 0) in the unnormalized texture
       // coordinate, which is the coordinate used by texelFetch().
       // e.g. when gl_FragCoord == (3.5, 3.5), this fragment shader covers
@@ skipping 438 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu