settled-reach/client/shaders/fog.gdshader

shader_type canvas_item;

// D-059: 5-layer fog shader. Composites over world content (layers 0-4).
// Layer 1: Clear (vision cone) — transparent, soft gradient edge
// Layer 2: Light fog (peripheral) — desaturated + dim + animated noise, 8-10s cycle
// Layer 3: Deep fog (explored) — near-monochrome + zone tint + breathing, 15-20s cycle
// Layer 4: Unexplored + maps — wireframe (Sprint 6: deferred, treated as Layer 5)
// Layer 5: Unexplored, no maps — solid near-black #12141a

uniform sampler2D visibility_tex : filter_linear, repeat_disable;
uniform sampler2D exploration_tex : filter_linear, repeat_disable;
uniform sampler2D zone_tint_tex : filter_nearest, repeat_disable;
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

// D-059 fog layer colors
const vec3 UNEXPLORED_COLOR = vec3(0.071, 0.078, 0.102);  // #12141a
const vec3 DARK_OVERLAY = vec3(0.02, 0.02, 0.05);

// D-059 thresholds
// Forward tiles = 1.0, Peripheral = 0.706 (180/255), not-visible = 0.0
const float CLEAR_THRESHOLD = 0.85;   // Above this: fully clear
// Lowered from 0.55 to capture blur-extended gradient tiles in the peripheral
// branch. The 7x7 Gaussian (sigma 2.0) produces values down to ~0.08 at
// 3 tiles from the LOS boundary — together with bilinear interpolation this
// yields the 6-8 sim tile soft edge specified by D-059/D-066.
const float PERIPHERAL_LOW = 0.08;

// D-059: Soft gradient via 7x7 Gaussian blur on visibility (sigma 2.0).
// The visibility texture is 1 texel per sim tile with discrete values
// (0 / 180 / 255). Bilinear filtering alone only smooths across ~1 tile.
// This blur spreads the LOS boundary into a 3-4 tile radius gradient;
// combined with smoothstep transitions, produces 6-8 tile soft edge.
// 49 taps from a tiny (~128x128) fully-cached texture — well under 1ms.
float sample_visibility(vec2 uv) {
    vec2 t = 1.0 / map_size;
    float sum = 0.0;
    float weight = 0.0;
    for (float dy = -3.0; dy <= 3.0; dy += 1.0) {
        for (float dx = -3.0; dx <= 3.0; dx += 1.0) {
            float w = exp(-(dx * dx + dy * dy) / 8.0);
            vec2 sample_uv = clamp(uv + vec2(dx, dy) * t, vec2(0.0), vec2(1.0));
            sum += texture(visibility_tex, sample_uv).r * w;
            weight += w;
        }
    }
    return sum / weight;
}

void fragment() {
    // Map UV (0-1 across ColorRect) to world pixels, then to tile coordinates
    vec2 world_px = rect_pos + UV * rect_sz;
    vec2 tile = world_px / tile_size;

    // Map tile coordinate to texture UV
    vec2 tex_uv = (tile - map_offset) / map_size;

    // Outside known map → unexplored
    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);
    } else {
        float vis_raw = texture(visibility_tex, tex_uv).r;
        float vis = sample_visibility(tex_uv);
        float explored = texture(exploration_tex, tex_uv).r;

        // Don't bleed gradient into never-explored tiles — keep them Layer 5
        if (explored < 0.01 && vis_raw < 0.01) {
            vis = 0.0;
        }

        if (vis > CLEAR_THRESHOLD) {
            // Layer 1: Clear — soft edge gradient
            // Alpha matches Layer 2 at boundary (coverage=1.0 → 0.25) for continuity
            float edge = smoothstep(CLEAR_THRESHOLD, 1.0, vis);
            COLOR = vec4(DARK_OVERLAY, 0.25 * (1.0 - edge));
        } else if (vis > PERIPHERAL_LOW || explored > 0.3) {
            // Layers 2-3: smooth blend between peripheral fog and deep fog.
            // Same gradient approach as the forward cone — smoothstep over the
            // blur radius eliminates stair-stepped tile edges at the back of
            // the vision cone.

            // Layer 2: peripheral fog
            float noise_val = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
            float coverage = smoothstep(PERIPHERAL_LOW, CLEAR_THRESHOLD, vis);
            float noise_weight = 1.0 - smoothstep(0.5, 1.0, coverage);
            float l2_alpha = mix(0.38, 0.25, coverage) + noise_val * 0.05 * noise_weight;

            // Layer 3: deep fog (explored, no longer in LOS)
            // D-059: near-monochrome, ~10% zone temperature tint, 15-20s breathing cycle
            vec3 zone_tint = texture(zone_tint_tex, tex_uv).rgb;
            float noise_deep = texture(noise_tex, tile * 0.015 + vec2(time * 0.06, time * 0.045)).r;
            vec3 tint_color = mix(vec3(0.04), zone_tint, 0.1);
            float l3_alpha = mix(0.62, 0.76, noise_deep);

            // Back-edge gradient: blend Layer 2 → Layer 3 over the blur radius.
            // PERIPHERAL_LOW * 3.0 ≈ 0.24 — matches the 3-4 tile Gaussian tail.
            float back_edge = smoothstep(0.0, PERIPHERAL_LOW * 3.0, vis);
            float alpha = mix(l3_alpha, l2_alpha, back_edge);
            vec3 color = mix(tint_color, DARK_OVERLAY, back_edge);
            COLOR = vec4(color, alpha);
        } else {
            // Layer 5: Unexplored, no maps — information zero
            COLOR = vec4(UNEXPLORED_COLOR, 1.0);
        }
    }
}