shader_type canvas_item;

// Parámetros ajustables
uniform float rain_speed : hint_range(0.1, 5.0) = 2.0;
uniform float rain_density : hint_range(0.0, 1.0) = 0.4;
uniform float rain_angle : hint_range(-1.0, 1.0) = +0.3;
uniform float rain_length : hint_range(0.05, 1.5) = 0.2;
uniform float rain_thickness : hint_range(0.005, 0.05) = 0.015;
uniform vec4 rain_color : source_color = vec4(0.8, 0.9, 1.0, 0.7);

// Parámetros del relámpago
uniform float lightning_intensity : hint_range(0.0, 1.0) = 0.0;
uniform vec4 lightning_color : source_color = vec4(1.0, 1.0, 1.0, 1.0);

// Función de ruido pseudo-aleatorio
float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}

void fragment() {
    vec2 uv = UV;
    
    // Movimiento de la lluvia
    float time_offset = TIME * rain_speed;
    
    // Crear múltiples capas de lluvia
    float rain = 0.0;
    
    for(int layer = 0; layer < 3; layer++) {
        float layer_offset = float(layer) * 0.33;
        vec2 rain_uv = uv;
        
        // Aplicar ángulo diagonal
        rain_uv.x += uv.y * rain_angle;
        
        // Escalar para crear las gotas individuales (menos escala = rayas más grandes)
        rain_uv.y -= time_offset + layer_offset;
        rain_uv *= vec2(15.0 + float(layer) * 5.0, 30.0 + float(layer) * 10.0);
        
        // Posición de cada celda
        vec2 cell_id = floor(rain_uv);
        vec2 cell_uv = fract(rain_uv);
        
        // Aleatorización por celda
        float rand = random(cell_id);
        
        // Filtrar gotas según densidad
        if(rand < rain_density) {
            // Posición X aleatoria dentro de la celda
            float x_offset = random(cell_id + vec2(0.5, 0.0));
            
            // Crear la línea de lluvia más gruesa
            float dist_x = abs(cell_uv.x - x_offset);
            float line = 1.0 - smoothstep(0.0, rain_thickness, dist_x);
            
            // Longitud de la gota (raya más larga)
            float length_mask = 1.0 - smoothstep(0.0, rain_length, cell_uv.y);
            length_mask *= smoothstep(0.0, 0.05, cell_uv.y);
            
            // Suavizar los extremos de la raya
            float fade_start = smoothstep(rain_length * 0.8, rain_length, cell_uv.y);
            length_mask *= (1.0 - fade_start * 0.7);
            
            rain += line * length_mask * (0.8 + rand * 0.2);
        }
    }
    
    // Limitar intensidad
    rain = clamp(rain, 0.0, 1.0);
    
    // Color final de la lluvia
    vec3 final_color = rain_color.rgb;
    float final_alpha = rain * rain_color.a;
    
    // Efecto de relámpago (flash blanco)
    vec3 lightning_effect = mix(final_color, lightning_color.rgb, lightning_intensity);
    final_alpha = max(final_alpha, lightning_intensity * lightning_color.a);
    
    // Output final
    COLOR = vec4(lightning_effect, final_alpha);
}