实现FXAA（翻译）

float rgb2luma(vec3 rgb) {
	return sqrt(dot(rgb, vec3(0.299, 0.587, 0.114)));
}

vec3 colorCenter = texture(screenTexture, In.uv).rgb;

// 当前像素的亮度
float lumaCenter = rgb2luma(colorCenter);

// 跟当前像素直接相邻的四个像素的亮度
float lumaDown = rgb2luma(textureOffset(screenTexture, In.uv, ivec2(0,-1)).rgb);
float lumaUp = rgb2luma(textureOffset(screenTexture, In.uv, ivec2(0,1)).rgb);
float lumaLeft = rgb2luma(textureOffset(screenTexture, In.uv, ivec2(-1,0)).rgb);
float lumaRight = rgb2luma(textureOffset(screenTexture, In.uv, ivec2(1,0)).rgb);

// 找到当前像素周围最大和最小的亮度
float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight)));
float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight)));

// 计算最大亮度和最小亮度的差
float lumaRange = lumaMax - lumaMin;

// 如果亮度变化低于阈值（或者在一个非常黑暗的区域），像素就不在边缘上，不执行任何AA。
if(lumaRange < max(EDGE_THRESHOLD_MIN,lumaMax * EDGE_THRESHOLD_MAX)) {
    fragColor = colorCenter;
    return;
}

// 查询剩余的4个角的亮度。
float lumaDownLeft = rgb2luma(textureOffset(screenTexture, In.uv,ivec2(-1, -1)).rgb);
float lumaUpRight = rgb2luma(textureOffset(screenTexture, In.uv,ivec2(1, 1)).rgb);
float lumaUpLeft = rgb2luma(textureOffset(screenTexture, In.uv,ivec2(-1, 1)).rgb);
float lumaDownRight = rgb2luma(textureOffset(screenTexture, In.uv,ivec2(1, -1)).rgb);

// 合并四条边的亮度（使用中间变量为未来计算相同的值）。
float lumaDownUp = lumaDown + lumaUp;
float lumaLeftRight = lumaLeft + lumaRight;

// 角落同样的处理
float lumaLeftCorners = lumaDownLeft + lumaUpLeft;
float lumaDownCorners = lumaDownLeft + lumaDownRight;
float lumaRightCorners = lumaDownRight + lumaUpRight;
float lumaUpCorners = lumaUpRight + lumaUpLeft;

// 沿水平和垂直轴向计算梯度的估计值。
float edgeHorizontal =  abs(-2.0 * lumaLeft + lumaLeftCorners)  + abs(-2.0 * lumaCenter + lumaDownUp ) * 2.0    + abs(-2.0 * lumaRight + lumaRightCorners);
float edgeVertical =    abs(-2.0 * lumaUp + lumaUpCorners)      + abs(-2.0 * lumaCenter + lumaLeftRight) * 2.0  + abs(-2.0 * lumaDown + lumaDownCorners);

// 边是水平的还是垂直的？
bool isHorizontal = (edgeHorizontal >= edgeVertical);

// 在与边相反的方向上选择两个相邻的纹理亮度。
float luma1 = isHorizontal ? lumaDown : lumaLeft;
float luma2 = isHorizontal ? lumaUp : lumaRight;
// 计算这个方向的梯度。
float gradient1 = luma1 - lumaCenter;
float gradient2 = luma2 - lumaCenter;

// 哪个方向最陡？
bool is1Steepest = abs(gradient1) >= abs(gradient2);

// 对应方向的梯度，归一化。
float gradientScaled = 0.25 * max(abs(gradient1), abs(gradient2));

// 根据边的方向选择步长（一个像素）。
float stepLength = isHorizontal ? inverseScreenSize.y : inverseScreenSize.x;

// 在正确方向上移动像素的亮度到中心像素亮度的局部平均亮度。
float lumaLocalAverage = 0.0;

if(is1Steepest){
    // 转换方向
    stepLength = - stepLength;
    lumaLocalAverage = 0.5*(luma1 + lumaCenter);
} else {
    lumaLocalAverage = 0.5*(luma2 + lumaCenter);
}

// 将UV向正确的方向移动半像素。
vec2 currentUv = In.uv;
if(isHorizontal){
    currentUv.y += stepLength * 0.5;
} else {
    currentUv.x += stepLength * 0.5;
}

// 在正确的方向上计算偏移量（每个迭代步骤）。
vec2 offset = isHorizontal ? vec2(inverseScreenSize.x,0.0) : vec2(0.0,inverseScreenSize.y);
// 计算uv以探索边缘的每一个方向。QUALITY值允许我们加快步伐。
vec2 uv1 = currentUv - offset;
vec2 uv2 = currentUv + offset;

// 读取探测段的两端亮度，并且计算亮度到局部平均亮度的
float lumaEnd1 = rgb2luma(texture(screenTexture,uv1).rgb);
float lumaEnd2 = rgb2luma(texture(screenTexture,uv2).rgb);
lumaEnd1 -= lumaLocalAverage;
lumaEnd2 -= lumaLocalAverage;

// 如果当前某一端的亮度差大于局部梯度，则说明已经达到边缘的一侧。
bool reached1 = abs(lumaEnd1) >= gradientScaled;
bool reached2 = abs(lumaEnd2) >= gradientScaled;
bool reachedBoth = reached1 && reached2;

// 如果没有到达边缘一侧，我们将继续朝着这个方向进行探测
if(!reached1){
    uv1 -= offset;
}
if(!reached2){
    uv2 += offset;
}

// 如果两边都还没有到达，则继续探测。
if(!reachedBoth){

    for(int i = 2; i < ITERATIONS; i++){
        // 如果没有到达一侧，读取第一个方向的亮度，计算差值。
        if(!reached1){
            lumaEnd1 = rgb2luma(texture(screenTexture, uv1).rgb);
            lumaEnd1 = lumaEnd1 - lumaLocalAverage;
        }
        // 如果没有到达另一侧，读取相反方向的亮度，计算差值。
        if(!reached2){
            lumaEnd2 = rgb2luma(texture(screenTexture, uv2).rgb);
            lumaEnd2 = lumaEnd2 - lumaLocalAverage;
        }
		// 如果当前端的亮度差值大于局部梯度，说明我们已经达到了边的一侧。
        // If the luma deltas at the current extremities is larger than the local gradient, we have reached the side of the edge.
        reached1 = abs(lumaEnd1) >= gradientScaled;
        reached2 = abs(lumaEnd2) >= gradientScaled;
        reachedBoth = reached1 && reached2;

        // 如果这一侧没有到达，我们用变量QUALITY继续沿着这个方向探测。
        if(!reached1){
            uv1 -= offset * QUALITY(i);
        }
        if(!reached2){
            uv2 += offset * QUALITY(i);
        }

        // 如果两侧都已经到达了，则停止探测。
        if(reachedBoth){ break;}
    }
}

// 计算当前像素到每一个端点的距离。
float distance1 = isHorizontal ? (In.uv.x - uv1.x) : (In.uv.y - uv1.y);
float distance2 = isHorizontal ? (uv2.x - In.uv.x) : (uv2.y - In.uv.y);

// 到哪个方向的端点最近？
bool isDirection1 = distance1 < distance2;
float distanceFinal = min(distance1, distance2);

// 边的长度。
float edgeThickness = (distance1 + distance2);

// UV偏移：读取离边的端点最近的一侧。
// distanceFinal / edgeThickness < 0.5；由于越接近端点，UV偏移需要越大，则取负数；+0.5使取值范围为正数。
float pixelOffset = - distanceFinal / edgeThickness + 0.5;

// 是否中心亮度小于局部平局亮度？
bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage;

// 如果中心的亮度比邻近的小，则两端的亮度差应均为正（变化相同）
// （在边缘较近的一边的方向。）
bool correctVariation = ((isDirection1 ? lumaEnd1 : lumaEnd2) < 0.0) != isLumaCenterSmaller;

// 如果亮度变化不正确，不要偏移。
float finalOffset = correctVariation ? pixelOffset : 0.0;

// 子像素转移
// 相邻的3x3像素的加权平均亮度。
float lumaAverage = (1.0/12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners);
// 求全局平均亮度和中心亮度的差，和3x3相邻的lumaRange的比值。
float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter)/lumaRange,0.0,1.0);
float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1;
// 计算基于此差值的子像素偏移量。
float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * SUBPIXEL_QUALITY;

// 从两个偏移量中选最大偏移量。
finalOffset = max(finalOffset,subPixelOffsetFinal);

// 计算最后的UV坐标。
vec2 finalUv = In.uv;
if(isHorizontal){
    finalUv.y += finalOffset * stepLength;
} else {
    finalUv.x += finalOffset * stepLength;
}

// 在新的UV坐标上读取颜色，并使用它。
vec3 finalColor = texture(screenTexture,finalUv).rgb;
fragColor = finalColor;