add wind + dust

Shaders/PolvereAtmosferica.gdshader

@@ -0,0 +1,85 @@
+shader_type canvas_item;
+
+uniform sampler2D screen_texture : hint_screen_texture, filter_linear_mipmap;
+
+// --- 1. COLORE E VISIBILITÀ ---
+// Ho alzato un po' l'Alpha base per renderli più visibili fin da subito
+uniform vec4 dust_color : source_color = vec4(1.0, 0.9, 0.7, 0.6);
+
+// --- 2. VENTO E MOVIMENTO ---
+// X negativo = verso sinistra. Y positivo = verso il basso.
+uniform vec2 wind_velocity = vec2(-0.2, 0.05); 
+uniform float wind_oscillation : hint_range(0.0, 1.0) = 0.3; 
+uniform float dust_speed : hint_range(0.01, 1.0) = 0.15;
+
+// --- 3. DIMENSIONI E DENSITÀ ---
+uniform float size_min : hint_range(0.001, 0.1) = 0.02; 
+uniform float size_max : hint_range(0.01, 0.5) = 0.2;
+uniform float dust_density : hint_range(0.01, 10.0) = 1.0;
+
+// --- 4. IL FIX DEL CENTRO (Morbidezza) ---
+// 0.0 = Sfumatura totale dal centro esatto fino al bordo.
+// 0.5 = Metà pallino è solido, l'altra metà sfuma.
+// 0.9 = Pallino dai bordi durissimi.
+uniform float solid_core : hint_range(0.0, 0.99) = 0.1;
+
+vec3 hash33(vec3 p3) {
+    p3 = fract(p3 * vec3(0.1031, 0.1030, 0.0973));
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.xxy + p3.yzz) * p3.zyx);
+}
+
+void fragment() {
+    vec4 scene_color = texture(screen_texture, SCREEN_UV);
+    float base_time = TIME * dust_speed;
+    
+    // Vento con oscillazione naturale
+    vec2 osc = vec2(sin(TIME * 0.5), cos(TIME * 0.3)) * wind_oscillation;
+    vec2 final_wind = (wind_velocity + osc) * dust_speed;
+
+    float final_particle_alpha = 0.0;
+    
+    // Configurazione dei 3 strati (Vicino, Medio, Lontano)
+    vec3 layer_scales = vec3(20.0, 50.0, 100.0) / dust_density; 
+    vec3 layer_thresholds = vec3(0.96, 0.98, 0.99); 
+    vec3 layer_speeds = vec3(1.0, 0.6, 0.3); 
+
+    for (int i = 0; i < 3; i++) {
+        float scale = layer_scales[i];
+        float threshold = layer_thresholds[i];
+        float speed_mult = layer_speeds[i];
+
+        // Spostiamo la griglia con il vento
+        vec2 st = (SCREEN_UV * scale) - (final_wind * speed_mult * base_time * 50.0);
+        vec2 ipos = floor(st);
+        vec2 fpos = fract(st);
+
+        vec3 rand = hash33(vec3(ipos, float(i)));
+
+        if (rand.z > threshold) {
+            // Effetto brillio
+            float blink = sin(TIME * (2.0 + rand.x)) * 0.5 + 0.5;
+            
+            float d = length(fpos - vec2(0.5));
+            float size = size_min + (size_max - size_min) * rand.x;
+            float scaled_size = size * (0.5 + 0.5 * blink); 
+            
+            // --- LA SOLUZIONE "ANTI-CIAMBELLA" ---
+            // Calcoliamo la grandezza del "nucleo solido" in proporzione alla grandezza totale.
+            float core = scaled_size * solid_core;
+            
+            // Se la distanza (d) è minore del 'core', l'opacità è 1.0. 
+            // Se va dal 'core' fino al bordo (scaled_size), sfuma dolcemente verso lo 0.0.
+            float particle_softness = 1.0 - smoothstep(core, scaled_size, d);
+            
+            // Uniamo tutto: morbidezza, brillio, e una correzione per l'intensità in base allo strato
+            float intensity = (rand.z - threshold) / (1.0 - threshold);
+            final_particle_alpha += particle_softness * blink * intensity;
+        }
+    }
+
+    final_particle_alpha = clamp(final_particle_alpha, 0.0, 1.0);
+    vec4 dust_colored_particle = dust_color * final_particle_alpha;
+
+    COLOR = scene_color + dust_colored_particle;
+}