shader_type canvas_item;

// D-059/D-015: 3-state fog shader (simplified from 5-layer by #569).
// State 1: Clear (forward cone) — transparent, soft gradient edge (6-8 tile radius)
// State 2: Explored (out of cone) — light fog overlay, alpha 0.25-0.35, zone temperature tint,
//          8-10s Perlin breathe. Art and information preserved, just "not fresh" (D-015).
// State 3: Unexplored — solid near-black #12141a
// D-033: Entity colors are NOT affected — they render above the fog overlay (z-layer 5).
// D-046: Zone temperature tint from zone_tint_tex — warm=bar, cool=hub, neutral=corridor.
// D-077: zone_tint_tex populated per-tile from server zone_id via fog_state.gd.
//
// Texture pipeline (fog_state.gd): binary 0/255 at 1× tile resolution → CPU Gaussian blur
// (sigma 2.0, 6-8 tile gradient) → Image.resize 4× bilinear upscale → RGBA8 convert.
// Textures arrive here with smooth sub-tile gradients — no GPU-side blur needed.

uniform sampler2D visibility_tex : filter_linear, repeat_disable;   // RGBA8, 4× tile resolution
uniform sampler2D exploration_tex : filter_linear, repeat_disable;  // RGBA8, 4× tile resolution
uniform sampler2D zone_tint_tex : filter_nearest, repeat_disable;   // D-073: hard zone boundaries
uniform sampler2D noise_tex : filter_linear, repeat_enable;
uniform vec2 rect_pos;       // World-space position of the ColorRect (pixels)
uniform vec2 rect_sz;        // World-space size of the ColorRect (pixels)
uniform vec2 map_offset;     // map_bounds.position (tiles)
uniform vec2 map_size;       // map_bounds.size (tiles)
uniform float tile_size;     // Pixels per sim tile
uniform float time;          // Seconds since start
uniform bool debug_exploration = false; // When true, render raw exploration texture

const vec3 UNEXPLORED_COLOR = vec3(0.071, 0.078, 0.102);  // #12141a

void fragment() {
    vec2 world_px = rect_pos + UV * rect_sz;
    vec2 tile = world_px / tile_size;
    vec2 tex_uv = (tile - map_offset) / map_size;

    // Outside known map -> unexplored
    // Note: no early return — fragment() in OpenGL3 compat doesn't support return.
    if (tex_uv.x < 0.0 || tex_uv.x > 1.0 || tex_uv.y < 0.0 || tex_uv.y > 1.0) {
        COLOR = vec4(UNEXPLORED_COLOR, 1.0);

    // Debug mode: render RAW exploration texture with filter_linear.
    // If hardware bilinear works, should show smooth sub-tile gradients.
    } else if (debug_exploration) {
        float explored_raw = texture(exploration_tex, tex_uv).r;
        COLOR = vec4(vec3(explored_raw), 0.9);

    } else {
        float vis = texture(visibility_tex, tex_uv).r;
        float explored = texture(exploration_tex, tex_uv).r;

        if (explored < 0.01 && vis < 0.01) {
            // Unexplored: solid near-black — information zero
            COLOR = vec4(UNEXPLORED_COLOR, 1.0);
        } else {
            // Fog noise — 8-10s breathe cycle, ±0.05 symmetric around baseline
            float noise_val = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
            float fog_alpha = 0.30 + (noise_val * 2.0 - 1.0) * 0.05;  // 0.25-0.35

            // Zone temperature tint (D-046/D-077): subtle warm/cool/neutral per zone
            vec3 zone_tint = texture(zone_tint_tex, tex_uv).rgb;

            // Clarity ramp: transparent inside cone, light fog at edges and beyond
            float clarity = smoothstep(0.0, 0.85, vis);
            float alpha = mix(fog_alpha, 0.0, clarity);
            vec3 color = mix(zone_tint, vec3(0.0), clarity);

            // Soft edge between explored and unexplored.
            // The exploration texture is binary (explored-or-not) blurred over ~12 tiles.
            // At the physical tile boundary, explored ≈ 0.5. Squaring the fade keeps
            // fog nearly opaque there (97%), hiding tile-aligned content edges.
            // Content appears gradually 4-6 tiles inside the explored area.
            float exp_fade = smoothstep(0.3, 1.0, explored);
            exp_fade *= exp_fade;  // Steeper curve: fog stays opaque near content edge
            alpha = mix(1.0, alpha, exp_fade);
            color = mix(UNEXPLORED_COLOR, color, exp_fade);

            COLOR = vec4(color, alpha);
        }
    }
}