#version 150

// Minecrafts eingebaute Variablen für die Bildschirmgröße
uniform float viewWidth;
uniform float viewHeight;

uniform sampler2D colortex0;
in vec2 texCoord;
out vec4 fragColor;

void main() {
    // Exakte Pixelgröße berechnen
    vec2 texelSize = vec2(1.0 / viewWidth, 1.0 / viewHeight);

    // =========================================================================
    // QUADRANT 1: Oben-Rechts (Top-Right)
    // =========================================================================
    float lumaSum_tr = 0.0;
    float lumaSquaredSum_tr = 0.0;
    vec3 colorSum_tr = vec3(0.0);

    for (int i = 0; i <= 36; i++) {
        for (int j = 0; j <= 36; j++) {
            vec2 offset = vec2(float(i), float(j)) * texelSize;
            vec3 neighborColor = texture(colortex0, texCoord + offset).rgb;
            float luma = dot(neighborColor, vec3(0.299, 0.587, 0.114));
            
            colorSum_tr += neighborColor;
            lumaSum_tr += luma;
            lumaSquaredSum_tr += (luma * luma);
        }
    }
    vec3 mean_tr = colorSum_tr / 1296.0;
    float mean_luma_tr = lumaSum_tr / 1296.0;
    float variance_tr = (lumaSquaredSum_tr / 1296.0) - (mean_luma_tr * mean_luma_tr);

    // =========================================================================
    // QUADRANT 2: Oben-Links (Top-Left)
    // =========================================================================
    float lumaSum_tl = 0.0;
    float lumaSquaredSum_tl = 0.0;
    vec3 colorSum_tl = vec3(0.0);

    for (int i = -36; i <= 0; i++) {
        for (int j = 0; j <= 36; j++) {
            vec2 offset = vec2(float(i), float(j)) * texelSize;
            vec3 neighborColor = texture(colortex0, texCoord + offset).rgb;
            float luma = dot(neighborColor, vec3(0.299, 0.587, 0.114));
            
            colorSum_tl += neighborColor;
            lumaSum_tl += luma;
            lumaSquaredSum_tl += (luma * luma);
        }
    }
    vec3 mean_tl = colorSum_tl / 1296.0;
    float mean_luma_tl = lumaSum_tl / 1296.0;
    float variance_tl = (lumaSquaredSum_tl / 1296.0) - (mean_luma_tl * mean_luma_tl);

    // =========================================================================
    // QUADRANT 3: Unten-Links (Bottom-Left)
    // =========================================================================
    float lumaSum_bl = 0.0;
    float lumaSquaredSum_bl = 0.0;
    vec3 colorSum_bl = vec3(0.0);

    for (int i = -36; i <= 0; i++) {
        for (int j = -36; j <= 0; j++) {
            vec2 offset = vec2(float(i), float(j)) * texelSize;
            vec3 neighborColor = texture(colortex0, texCoord + offset).rgb;
            float luma = dot(neighborColor, vec3(0.299, 0.587, 0.114));
            
            colorSum_bl += neighborColor;
            lumaSum_bl += luma;
            lumaSquaredSum_bl += (luma * luma);
        }
    }
    vec3 mean_bl = colorSum_bl / 1296.0;
    float mean_luma_bl = lumaSum_bl / 1296.0;
    float variance_bl = (lumaSquaredSum_bl / 1296.0) - (mean_luma_bl * mean_luma_bl);

    // =========================================================================
    // QUADRANT 4: Unten-Rechts (Bottom-Right)
    // =========================================================================
    float lumaSum_br = 0.0;
    float lumaSquaredSum_br = 0.0;
    vec3 colorSum_br = vec3(0.0);

    for (int i = 0; i <= 36; i++) {
        for (int j = -36; j <= 0; j++) {
            vec2 offset = vec2(float(i), float(j)) * texelSize;
            vec3 neighborColor = texture(colortex0, texCoord + offset).rgb;
            float luma = dot(neighborColor, vec3(0.299, 0.587, 0.114));
            
            colorSum_br += neighborColor;
            lumaSum_br += luma;
            lumaSquaredSum_br += (luma * luma);
        }
    }
    vec3 mean_br = colorSum_br / 1296.0;
    float mean_luma_br = lumaSum_br / 1296.0;
    float variance_br = (lumaSquaredSum_br / 1296.0) - (mean_luma_br * mean_luma_br);

    // =========================================================================
    // FINALE AUSWAHL: Den Quadranten mit der NIEDRIGSTEN Varianz finden
    // =========================================================================
// 1. Varianzen direkt für den harten Effekt quadrieren
    float v_tr = variance_tr * variance_tr;
    float v_tl = variance_tl * variance_tl;
    float v_bl = variance_bl * variance_bl;
    float v_br = variance_br * variance_br;

    // 2. Sauberer Vergleich der quadrierten Werte
    float minVariance = v_tr;
    vec3 finalColor = mean_tr;

    if (v_tl < minVariance) {
        minVariance = v_tl;
        finalColor = mean_tl;
    }
    if (v_bl < minVariance) {
        minVariance = v_bl;
        finalColor = mean_bl;
    }
    if (v_br < minVariance) {
        minVariance = v_br;
        finalColor = mean_br;
    }

    fragColor = vec4(finalColor, 1.0);
}