at the 7th try i think

acrd.glsl

/*
===============================================================================
ACRD: Contrast Analysis and Directional Reconstruction v1.2
===============================================================================
High-performance post-processing anti-aliasing that detects edges using
luminance analysis and smooths them through directional reconstruction.

Algorithm Overview:
1. Detects edges by calculating local contrast with minimal initial sampling
2. Uses Sobel gradient to determine precise edge direction
3. Samples along the edge to reconstruct smoothed color
4. Blends result based on detected contrast intensity

Key Optimizations:
- Early exit: avoids processing in flat areas (5 vs 9 samples)
- Directional sampling: only smooths in the correct edge direction
- Runtime control: uniform parameters allow real-time adjustment
===============================================================================
*/

#version 330 core
precision mediump float;

in vec2 uv;

uniform sampler2D screenTexture;
uniform vec2 texelSize;              // vec2(1.0/width, 1.0/height)

// Quality controls (adjustable at runtime)
uniform float u_edge_threshold;      // [0.03-0.125] Detection sensitivity
uniform float u_subpixel_offset;     // [0.25-0.75] Sampling distance (recommended: 0.5)

out vec4 fragColor;

// Standard Rec. 709 luminance coefficients
const vec3 LUMA_WEIGHTS = vec3(0.2126, 0.7152, 0.0722);

void main()
{
    /*
    PHASE 1: INITIAL EDGE DETECTION
    ===============================
    Minimal sampling to detect if we're on a potential edge.
    Only uses the 5 cardinal pixels (center + N,S,E,W) for optimization.
    */
    
    vec3 colorCenter = texture(screenTexture, uv).rgb;
    float lumaCenter = dot(colorCenter, LUMA_WEIGHTS);

    // Sample cardinal neighbors
    float lumaN = dot(texture(screenTexture, uv + vec2(0.0, texelSize.y)).rgb, LUMA_WEIGHTS);
    float lumaS = dot(texture(screenTexture, uv + vec2(0.0, -texelSize.y)).rgb, LUMA_WEIGHTS);
    float lumaE = dot(texture(screenTexture, uv + vec2(texelSize.x, 0.0)).rgb, LUMA_WEIGHTS);
    float lumaW = dot(texture(screenTexture, uv + vec2(-texelSize.x, 0.0)).rgb, LUMA_WEIGHTS);

    // Calculate local contrast
    float lumaMin = min(lumaCenter, min(lumaN, min(lumaS, min(lumaE, lumaW))));
    float lumaMax = max(lumaCenter, max(lumaN, max(lumaS, max(lumaE, lumaW))));
    float contrast = lumaMax - lumaMin;

    // Early exit for flat areas
    if (contrast < u_edge_threshold) {
        fragColor = vec4(colorCenter, 1.0);
        return;
    }

    /*
    PHASE 2: COMPLETE DIRECTIONAL ANALYSIS
    ======================================
    Once edge is confirmed, invest in full 8-neighbor sampling
    to calculate precise direction using Sobel operator.
    */
    
    // Sample diagonal corners
    float lumaNW = dot(texture(screenTexture, uv + vec2(-texelSize.x, texelSize.y)).rgb, LUMA_WEIGHTS);
    float lumaNE = dot(texture(screenTexture, uv + vec2(texelSize.x, texelSize.y)).rgb, LUMA_WEIGHTS);
    float lumaSW = dot(texture(screenTexture, uv + vec2(-texelSize.x, -texelSize.y)).rgb, LUMA_WEIGHTS);
    float lumaSE = dot(texture(screenTexture, uv + vec2(texelSize.x, -texelSize.y)).rgb, LUMA_WEIGHTS);

    // Sobel operator for gradient detection
    float sobelX = -lumaNW - 2.0 * lumaW - lumaSW + lumaNE + 2.0 * lumaE + lumaSE;
    float sobelY = -lumaSW - 2.0 * lumaS - lumaSE + lumaNW + 2.0 * lumaN + lumaNE;

    // Gradient points perpendicular to edge, rotate 90° to get edge direction
    vec2 edgeDirection = normalize(vec2(-sobelY, sobelX));

    /*
    PHASE 3: DIRECTIONAL RECONSTRUCTION
    ===================================
    Sample along the detected edge and average to smooth aliasing.
    */
    
    vec2 sampleOffset = edgeDirection * texelSize * u_subpixel_offset;
    
    // Symmetric samples along the edge
    vec3 colorA = texture(screenTexture, uv + sampleOffset).rgb;
    vec3 colorB = texture(screenTexture, uv - sampleOffset).rgb;
    vec3 reconstructedColor = (colorA + colorB) * 0.5;

    /*
    PHASE 4: ADAPTIVE BLENDING
    ==========================
    Blend original with reconstructed based on contrast strength.
    Preserves fine details while smoothing pronounced edges.
    */
    
    // Smooth blend factor based on contrast strength
    float blendFactor = smoothstep(u_edge_threshold, u_edge_threshold * 2.0, contrast);
    vec3 finalColor = mix(colorCenter, reconstructedColor, blendFactor);

    fragColor = vec4(finalColor, 1.0);
}