gpu, cmaa: avoid == for float in GLSL

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 1485 matching lines @@
 
       for (int _i = 0; _i < 4; _i++) {
         int _x = _i % 2;
         int _y = _i / 2;
 
         ivec3 screenPosI = screenPosIBase + ivec3(_x, _y, 0);
 
         uint packedEdgesC = packedEdgesArray[(1 + _x) * 4 + (1 + _y)];
 
         uvec4 edges = UnpackEdge(packedEdgesC);
-        vec4 edgesFlt = vec4(edges);
-
-        float numberOfEdges = dot(edgesFlt, vec4(1, 1, 1, 1));
-        if (numberOfEdges <= 1.0)
+        uint numberOfEdges = edges.x + edges.y + edges.z + edges.w;
+        if (numberOfEdges <= 1u)
           continue;
 
+        vec4 edgesFlt = vec4(edges);
         float fromRight = edgesFlt.r;
         float fromAbove = edgesFlt.g;
         float fromLeft = edgesFlt.b;
         float fromBelow = edgesFlt.a;
 
         vec4 xFroms = vec4(fromBelow, fromAbove, fromRight, fromLeft);
 
         float blurCoeff = 0.0;
 
         // These are additional blurs that complement the main line-based
         // blurring; Unlike line-based, these do not necessarily preserve
         // the total amount of screen colour as they will take
         // neighbouring pixel colours and apply them to the one currently
         // processed.
 
         // 1.) L-like shape.
         // For this shape, the total amount of screen colour will be
         // 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 )
+        if (numberOfEdges == 2u)
         {
           // 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.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);
@@ skipping 50 matching lines @@
           bool isolated_l4 = (packedEdgesC == (0x02u | 0x04u)) &&
                            bool((packedEdgesL & 0x08u) == 0x00u) &&
                            bool((packedEdgesT & 0x01u) == 0x00u) &&
                            bool((packedEdgesR & 0x02u) == 0x00u) &&
                            bool((packedEdgesB & 0x04u) == 0x00u);
           if (isolated_l1 || isolated_l2 || isolated_l3 || isolated_l4)
             continue;
         }
 
         // 2.) U-like shape (surrounded with edges from 3 sides)
-        if (numberOfEdges == 3.0) {
+        if (numberOfEdges == 3u) {
           // 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.13;
         }
 
         // 3.) Completely surrounded with edges from all 4 sides
-        if (numberOfEdges == 4.0) {
+        if (numberOfEdges == 4u) {
           // 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.07;
         }
 
         // |blurCoeff| must be not zero at this point.
         vec4 blurMap = xFroms * blurCoeff;
 
         vec4 pixelC = texelFetch(g_screenTexture, screenPosI.xy, 0);
@@ skipping 39 matching lines @@
 
         color /= fourWeightSum + 0.0001;
 
         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)));
+                   PackBlurAAInfo(screenPosI.xy, numberOfEdges));
     \n#endif\n
         imageStore(g_resultTextureFlt4Slot1, screenPosI.xy, color);
 
-        if (numberOfEdges == 2.0) {
+        if (numberOfEdges == 2u) {
           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)) &&
              ((packedEdgesR & 0x02u) == 0x02u);
 
@@ skipping 214 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu