gpu, cmaa: blend color like bilinear filter

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 1505 matching lines @@
         // preserved when this is a part of a (zigzag) diagonal line as the
         // corners from the other side  will do the same and take some of
         // the current pixel's colour in return.
         // However, in the case when this is an actual corner, the pixel's
         // colour will be partially overwritten by it's 2 neighbours.
         if( numberOfEdges == 2.0 )
         {
           // with value of 0.15, the pixel will retain approx 77% of its
           // colour and the remaining 23% will come from its 2 neighbours
           // (which are likely to be blurred too in the opposite direction)
-          blurCoeff = 0.08;
+          blurCoeff = 0.15;
 
           // Only do blending if it's L shape - if we're between two
           // parallel edges, don't do anything
           blurCoeff *= (1.0 - fromBelow * fromAbove) *
                        (1.0 - fromRight * fromLeft);
 
           if (blurCoeff == 0.0)
             continue;
 
           uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];
@@ skipping 21 matching lines @@
                            bool(packedEdgesB & 0x04u);
           if (large_l1 || large_l2 || large_l3 || large_l4)
             continue;
         }
 
         // 2.) U-like shape (surrounded with edges from 3 sides)
         if (numberOfEdges == 3.0) {
           // with value of 0.13, the pixel will retain approx 72% of its
           // colour and the remaining 28% will be picked from its 3
           // neighbours (which are unlikely to be blurred too but could be)
-          blurCoeff = 0.11;
+          blurCoeff = 0.13;
         }
 
         // 3.) Completely surrounded with edges from all 4 sides
         if (numberOfEdges == 4.0) {
           // with value of 0.07, the pixel will retain 78% of its colour
           // and the remaining 22% will come from its 4 neighbours (which
           // are unlikely to be blurred)
-          blurCoeff = 0.05;
+          blurCoeff = 0.07;
         }
 
         if (blurCoeff == 0.0) {
           // this avoids Z search below as well but that's ok because a Z
           // shape will also always have some blurCoeff
           continue;
         }
 
         vec4 blurMap = xFroms * blurCoeff;
 
@@ skipping 11 matching lines @@
         // float fromBelowWeight = (1.0 / (1.0 - blurMap.x)) - 1.0;
         // float fromAboveWeight = (1.0 / (1.0 - blurMap.y)) - 1.0;
         // float fromRightWeight = (1.0 / (1.0 - blurMap.z)) - 1.0;
         // float fromLeftWeight  = (1.0 / (1.0 - blurMap.w)) - 1.0;
 
         float fourWeightSum = dot(blurMap, vec4(1, 1, 1, 1));
         float allWeightSum = centerWeight + fourWeightSum;
 
         vec4 color = vec4(0, 0, 0, 0);
         if (fromLeftWeight > 0.0) {
-          vec3 pixelL = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(-1, 0)).rgb;
-          color.rgb += fromLeftWeight * pixelL;
+          vec4 pixelL = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
+                                         ivec2(-1, 0));
+          color += fromLeftWeight * pixelL;
         }
         if (fromAboveWeight > 0.0) {
-          vec3 pixelT = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(0, 1)).rgb;
-          color.rgb += fromAboveWeight * pixelT;
+          vec4 pixelT = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
+                                         ivec2(0, 1));
+          color += fromAboveWeight * pixelT;
         }
         if (fromRightWeight > 0.0) {
-          vec3 pixelR = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(1, 0)).rgb;
-          color.rgb += fromRightWeight * pixelR;
+          vec4 pixelR = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
+                                         ivec2(1, 0));
+          color += fromRightWeight * pixelR;
         }
         if (fromBelowWeight > 0.0) {
-          vec3 pixelB = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(0, -1)).rgb;
-          color.rgb += fromBelowWeight * pixelB;
+          vec4 pixelB = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
+                                         ivec2(0, -1));
+          color += fromBelowWeight * pixelB;
         }
 
         color /= fourWeightSum + 0.0001;
-        color.a = 1.0 - centerWeight / allWeightSum;
 
-        color.rgb = mix(pixelC.rgb, color.rgb, color.a).rgb;
+        color = mix(color, pixelC, centerWeight / allWeightSum);
     \n#ifdef IN_GAMMA_CORRECT_MODE\n
         color.rgb = D3DX_FLOAT3_to_SRGB(color.rgb);
     \n#endif\n
 
     \n#ifdef DEBUG_OUTPUT_AAINFO\n
         imageStore(g_resultTextureSlot2, screenPosI.xy,
                    PackBlurAAInfo(screenPosI.xy, uint(numberOfEdges)));
     \n#endif\n
-        imageStore(g_resultTextureFlt4Slot1, screenPosI.xy,
-                   vec4(color.rgb, pixelC.a));
+        imageStore(g_resultTextureFlt4Slot1, screenPosI.xy, color);
 
         if (numberOfEdges == 2.0) {
           uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];
           uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];
           uint packedEdgesR = packedEdgesArray[(2 + _x) * 4 + (1 + _y)];
           uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];
 
           bool isHorizontalA = ((packedEdgesC) == (0x01u | 0x02u)) &&
              ((packedEdgesR & 0x08u) == 0x08u);
           bool isHorizontalB = ((packedEdgesC) == (0x01u | 0x08u)) &&
@@ skipping 216 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu