gpu, cmaa: bottom to top is always y-direction.

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 787 matching lines @@
       outVal.x = D3DX_FLOAT_to_SRGB(val.x);
       outVal.y = D3DX_FLOAT_to_SRGB(val.y);
       outVal.z = D3DX_FLOAT_to_SRGB(val.z);
       return outVal;
     }
     ///////////////////////////////////////////////////////////////////////
     \n#endif\n  // IN_GAMMA_CORRECT_MODE
 
     // how .rgba channels from the edge texture maps to pixel edges:
     //
-    //                   A - 0x08
+    //                   A - 0x02
     //              |¯¯¯¯¯¯¯¯¯|
     //              |         |
     //     0x04 - B |  pixel  | R - 0x01
     //              |         |
     //              |_________|
-    //                   G - 0x02
+    //                   G - 0x08
     //
-    // (A - there's an edge between us and a pixel above us)
+    // (A - there's an edge between us and a pixel at the bottom)
     // (R - there's an edge between us and a pixel to the right)
-    // (G - there's an edge between us and a pixel at the bottom)
+    // (G - there's an edge between us and a pixel above us)
     // (B - there's an edge between us and a pixel to the left)
 
     // Expecting values of 1 and 0 only!
     uint PackEdge(uvec4 edges) {
       return (edges.x << 0u) | (edges.y << 1u) | (edges.z << 2u) |
              (edges.w << 3u);
     }
 
     uvec4 UnpackEdge(uint value) {
       uvec4 ret;
@@ skipping 80 matching lines @@
                         const bool horizontal,
                         const bool invertedZShape,
                         const ivec2 stepRight) {
       // TODO: there must be a cleaner and faster way to get to these -
       // a precalculated array indexing maybe?
       uint maskLeft = uint(0);
       uint bitsContinueLeft = uint(0);
       uint maskRight = uint(0);
       uint bitsContinueRight = uint(0);
       {
-      // Horizontal (vertical is the same, just rotated 90º
-      // counter-clockwise)
+      // Horizontal (vertical is the same, just rotated 90º counter-clockwise)
       // Inverted Z case:              // Normal Z case:
       //   __                          // __
       //  X|                           //  X|
       // --                            //    --
       //
+      // Vertical
+      // Inverted Z case:              // Normal Z case:
+      //  |                            //   |
+      //   --                          //  --
+      //   X|                          // |X
         uint maskTraceLeft = uint(0);
         uint maskTraceRight = uint(0);
         uint maskStopLeft = uint(0);
         uint maskStopRight = uint(0);
         if (horizontal) {
           if (invertedZShape) {
-            maskTraceLeft = 0x02u;  // tracing bottom edge
-            maskTraceRight = 0x08u; // tracing top edge
+            maskTraceLeft = 0x08u;  // tracing bottom edge
+            maskTraceRight = 0x02u; // tracing top edge
           } else {
-            maskTraceLeft = 0x08u;  // tracing top edge
-            maskTraceRight = 0x02u; // tracing bottom edge
+            maskTraceLeft = 0x02u;  // tracing top edge
+            maskTraceRight = 0x08u; // tracing bottom edge
           }
           maskStopLeft = 0x01u;  // stop on right edge
           maskStopRight = 0x04u; // stop on left edge
         } else {
           if (invertedZShape) {
             maskTraceLeft = 0x01u;  // tracing right edge
             maskTraceRight = 0x04u; // tracing left edge
           } else {
             maskTraceLeft = 0x04u;  // tracing left edge
             maskTraceRight = 0x01u; // tracing right edge
           }
-          maskStopLeft = 0x08u;  // stop on top edge
-          maskStopRight = 0x02u; // stop on bottom edge
+          maskStopLeft = 0x02u;  // stop on top edge
+          maskStopRight = 0x08u; // stop on bottom edge
         }
 
         maskLeft = maskTraceLeft | maskStopLeft;
         bitsContinueLeft = maskTraceLeft;
         maskRight = maskTraceRight | maskStopRight;
         bitsContinueRight = maskTraceRight;
       }
     ///////////////////////////////////////////////////////////////////////
 
     \n#ifdef SETTINGS_ALLOW_SHORT_Zs\n
@@ skipping 23 matching lines @@
       }
       lineLengthLeft = lineLengthRight = i;
       return;
     }
 
     void ProcessDetectedZ(ivec2 screenPos, bool horizontal,
                           bool invertedZShape) {
       int lineLengthLeft = 0;
       int lineLengthRight = 0;
 
-      ivec2 stepRight = (horizontal) ? (ivec2(1, 0)) : (ivec2(0, -1));
-      vec2 blendDir = (horizontal) ? (vec2(0, -1)) : (vec2(-1, 0));
+      ivec2 stepRight = (horizontal) ? (ivec2(1, 0)) : (ivec2(0, 1));
+      vec2 blendDir = (horizontal) ? (vec2(0, -1)) : (vec2(1, 0));
 
       FindLineLength(lineLengthLeft, lineLengthRight, screenPos,
                      horizontal, invertedZShape, stepRight);
 
       vec2 pixelSize = g_OneOverScreenSize;
 
       float leftOdd = 0.15 * float(lineLengthLeft % 2);
       float rightOdd = 0.15 * float(lineLengthRight % 2);
 
       int loopFrom = -int((lineLengthLeft + 1) / 2) + 1;
       int loopTo = int((lineLengthRight + 1) / 2);
 
       float totalLength = float(loopTo - loopFrom) + 1.0 - leftOdd -
                           rightOdd;
 
       for (int i = loopFrom; i <= loopTo; i++) {
         highp ivec2 pixelPos = screenPos + stepRight * i;
         vec2 pixelPosFlt = vec2(float(pixelPos.x) + 0.5,
                                 float(pixelPos.y) + 0.5);
 
     \n#ifdef DEBUG_OUTPUT_AAINFO\n
         imageStore(g_resultTextureSlot2, pixelPos,
                    PackBlurAAInfo(pixelPos, 1u));
     \n#endif\n
 
         float m = (float(i) + 0.5 - leftOdd - float(loopFrom)) /
                    totalLength;
         m = saturate(m);
         float k = m - ((i > 0) ? 1.0 : 0.0);
-        k = (invertedZShape) ? (-k) : (k);
+        k = (invertedZShape) ? (k) : (-k);
 
         vec4 color = textureLod(g_screenTexture,
                                 (pixelPosFlt + blendDir * k) * pixelSize,
                                 0.0);
 
     \n#ifdef IN_GAMMA_CORRECT_MODE\n
         color.rgb = D3DX_FLOAT3_to_SRGB(color.rgb);
     \n#endif\n
         imageStore(g_resultTextureFlt4Slot1, pixelPos, color);
       }
@@ skipping 440 matching lines @@
         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 < 2.0)
           continue;
 
         float fromRight = edgesFlt.r;
-        float fromBelow = edgesFlt.g;
+        float fromAbove = edgesFlt.g;
         float fromLeft = edgesFlt.b;
-        float fromAbove = edgesFlt.a;
+        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.
@@ skipping 62 matching lines @@
         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;
         }
         if (fromAboveWeight > 0.0) {
           vec3 pixelT = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(0, -1)).rgb;
+                                         ivec2(0, 1)).rgb;
           color.rgb += fromAboveWeight * pixelT;
         }
         if (fromRightWeight > 0.0) {
           vec3 pixelR = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
                                          ivec2(1, 0)).rgb;
           color.rgb += fromRightWeight * pixelR;
         }
         if (fromBelowWeight > 0.0) {
           vec3 pixelB = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,
-                                         ivec2(0, 1)).rgb;
+                                         ivec2(0, -1)).rgb;
           color.rgb += fromBelowWeight * pixelB;
         }
 
         color /= fourWeightSum + 0.0001;
         color.a = 1.0 - centerWeight / allWeightSum;
 
         color.rgb = mix(pixelC.rgb, color.rgb, color.a).rgb;
     \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));
 
         if (numberOfEdges == 2.0) {
           uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];
-          uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];
+          uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];
           uint packedEdgesR = packedEdgesArray[(2 + _x) * 4 + (1 + _y)];
-          uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];
+          uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];
 
           bool isHorizontalA = ((packedEdgesC) == (0x01u | 0x02u)) &&
-             ((packedEdgesR & (0x01u | 0x08u)) == (0x08u));
+             ((packedEdgesR & 0x08u) == 0x08u);
           bool isHorizontalB = ((packedEdgesC) == (0x01u | 0x08u)) &&
-             ((packedEdgesR & (0x01u | 0x02u)) == (0x02u));
+             ((packedEdgesR & 0x02u) == 0x02u);
 
           bool isHCandidate = isHorizontalA || isHorizontalB;
 
-          bool isVerticalA = ((packedEdgesC) == (0x08u | 0x01u)) &&
-             ((packedEdgesT & (0x08u | 0x04u)) == (0x04u));
-          bool isVerticalB = ((packedEdgesC) == (0x08u | 0x04u)) &&
-             ((packedEdgesT & (0x08u | 0x01u)) == (0x01u));
+          bool isVerticalA = ((packedEdgesC) == (0x02u | 0x04u)) &&
+             ((packedEdgesT & 0x01u) == 0x01u);
+          bool isVerticalB = ((packedEdgesC) == (0x01u | 0x02u)) &&
+             ((packedEdgesT & 0x04u) == 0x04u);
           bool isVCandidate = isVerticalA || isVerticalB;
 
           bool isCandidate = isHCandidate || isVCandidate;
 
           if (!isCandidate)
             continue;
 
           bool horizontal = isHCandidate;
 
           // what if both are candidates? do additional pruning (still not
           // 100% but gets rid of worst case errors)
           if (isHCandidate && isVCandidate)
             horizontal =
                (isHorizontalA && ((packedEdgesL & 0x02u) == 0x02u)) ||
                (isHorizontalB && ((packedEdgesL & 0x08u) == 0x08u));
 
           ivec2 offsetC;
           uint packedEdgesM1P0;
           uint packedEdgesP1P0;
           if (horizontal) {
             packedEdgesM1P0 = packedEdgesL;
             packedEdgesP1P0 = packedEdgesR;
             offsetC = ivec2(2, 0);
           } else {
             packedEdgesM1P0 = packedEdgesB;
             packedEdgesP1P0 = packedEdgesT;
-            offsetC = ivec2(0, -2);
+            offsetC = ivec2(0, 2);
           }
 
           uvec4 edgesM1P0 = UnpackEdge(packedEdgesM1P0);
           uvec4 edgesP1P0 = UnpackEdge(packedEdgesP1P0);
           uvec4 edgesP2P0 = UnpackEdge(uint(texelFetch(
              g_src0TextureFlt, screenPosI.xy + offsetC, 0).r * 255.5));
 
           uvec4 arg0;
           uvec4 arg1;
           uvec4 arg2;
           uvec4 arg3;
           bool arg4;
 
           if (horizontal) {
             arg0 = uvec4(edges);
             arg1 = edgesM1P0;
             arg2 = edgesP1P0;
             arg3 = edgesP2P0;
             arg4 = true;
           } else {
             // Reuse the same code for vertical (used for horizontal above)
-            // but rotate input data 90º counter-clockwise, so that:
-            // left     becomes     bottom
-            // top      becomes     left
-            // right    becomes     top
-            // bottom   becomes     right
-
-            // we also have to rotate edges, thus .argb
-            arg0 = uvec4(edges.argb);
-            arg1 = edgesM1P0.argb;
-            arg2 = edgesP1P0.argb;
-            arg3 = edgesP2P0.argb;
+            // but rotate input data 90º counter-clockwise. See FindLineLength()
+            // e.g. arg0.r (new top) must be mapped to edges.g (old top)
+            arg0 = uvec4(edges.gbar);
+            arg1 = edgesM1P0.gbar;
+            arg2 = edgesP1P0.gbar;
+            arg3 = edgesP2P0.gbar;
             arg4 = false;
           }
 
           {
             ivec2 screenPos = screenPosI.xy;
             uvec4 _edges = arg0;
             uvec4 _edgesM1P0 = arg1;
             uvec4 _edgesP1P0 = arg2;
             uvec4 _edgesP2P0 = arg3;
             bool horizontal = arg4;
-            // Inverted Z case:
-            //   __
+
+            // Normal Z case:
+            // __
             //  X|
-            // ¯¯
+            //   ¯¯
             bool isInvertedZ = false;
             bool isNormalZ = false;
             {
     \n#ifndef SETTINGS_ALLOW_SHORT_Zs\n
               // (1u-_edges.a) constraint can be removed; it was added for
               // some rare cases
               uint isZShape = _edges.r * _edges.g * _edgesM1P0.g *
                  _edgesP1P0.a *_edgesP2P0.a * (1u - _edges.b) *
                   (1u - _edgesP1P0.r) * (1u - _edges.a) *
                   (1u - _edgesP1P0.g);
     \n#else\n
               uint isZShape = _edges.r * _edges.g * _edgesP1P0.a *
                   (1u - _edges.b) * (1u - _edgesP1P0.r) * (1u - _edges.a) *
                               (1u - _edgesP1P0.g);
               isZShape *= (_edgesM1P0.g + _edgesP2P0.a);
                               // and at least one of these need to be there
     \n#endif\n
               if (isZShape > 0u) {
-                isInvertedZ = true;
+                isNormalZ = true;
               }
             }
 
-            // Normal Z case:
-            // __
+            // Inverted Z case:
+            //   __
             //  X|
-            //   ¯¯
+            // ¯¯
             {
     \n#ifndef SETTINGS_ALLOW_SHORT_Zs\n
               uint isZShape = _edges.r * _edges.a * _edgesM1P0.a *
                   _edgesP1P0.g * _edgesP2P0.g * (1u - _edges.b) *
                   (1u - _edgesP1P0.r) * (1u - _edges.g) *
                   (1u - _edgesP1P0.a);
     \n#else\n
               uint isZShape = _edges.r * _edges.a * _edgesP1P0.g *
                   (1u - _edges.b) * (1u - _edgesP1P0.r) * (1u - _edges.g) *
                   (1u - _edgesP1P0.a);
               isZShape *=
                   (_edgesM1P0.a + _edgesP2P0.g);
                               // and at least one of these need to be there
     \n#endif\n
 
               if (isZShape > 0u) {
-                isNormalZ = true;
+                isInvertedZ = true;
               }
             }
 
             bool isZ = isInvertedZ || isNormalZ;
             if (isZ) {
               forFollowUpCoords[forFollowUpCount++] =
                   ivec4(screenPosI.xy, horizontal, isInvertedZ);
             }
           }
         }
@@ skipping 86 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu