test other scenes and fix

core/daynight/day_night_controller.gd

@@ -24,7 +24,6 @@ func _ready() -> void:
 
 	current_time = start_time
 	update_time(current_time)
-	
 
 func _process(delta: float) -> void:
 	if paused or environment_config.day_duration <= 0.0:

core/daynight/environment_manager.gd

@@ -67,14 +67,14 @@ func _ready() -> void:
 
 func ApplyWindNoiseToMaterials():
 	var noise_tex = preload("res://core/daynight/noise.tres")
-	for node in get_tree().get_nodes_in_group("wind_materials"):
+	for node in get_tree().get_nodes_in_group("wind_node"):
 		if node is GeometryInstance3D:
 			node.material_override.set_shader_parameter("wind_noise", noise_tex)
 			
 func ApplyWeatherShaderToMaterials():
 	var weather_shader = preload("res://core/daynight/weather_overlay.tres")
 
-	for node in get_tree().get_nodes_in_group("weather_materials"):
+	for node in get_tree().get_nodes_in_group("weather_node"):
 		if node is GeometryInstance3D:
 			node.material_overlay = weather_shader
 		else:
@@ -83,25 +83,25 @@ func ApplyWeatherShaderToMaterials():
 					child.material_overlay = weather_shader
 
 func select_day_time(normalized_time: float) -> void:
-	# 0.0→0.25  = alba:       day_time 1.0→2.0 (night colors → morning colors)
-	# 0.25→0.5  = giorno:     day_time 2.0→2.0 (stays morning/afternoon)
-	# 0.5→0.75  = tramonto:   day_time 2.0→3.0 (afternoon colors → night colors)
-	# 0.75→1.0  = notte:      day_time 3.0→3.0 (stays night)
-	# At wrap 1.0→0.0:        day_time stays 3.0, then fades back via alba
+	# 0.0→0.25  = sunrise:    day_time 1.0→2.0 (night colors → morning colors)
+	# 0.25→0.5  = day:        day_time 2.0→2.0 (stays morning/afternoon)
+	# 0.5→0.75  = sunset:     day_time 2.0→3.0 (afternoon colors → night colors)
+	# 0.75→1.0  = night:      day_time 3.0→3.0 (stays night)
+	# At wrap 1.0→0.0:        day_time stays 3.0, then fades back via sunrise
 	
 	if normalized_time < 0.25:
-		# Alba: notte → mattina
+		#Sunrise: night → morning
 		day_time = 3.0 - (normalized_time / 0.25) * 2.0  # 3.0 → 1.0
 	elif normalized_time < 0.5:
-		# Giorno pieno
+		#Broad daylight
 		var t: float = (normalized_time - 0.25) / 0.25
 		day_time = 1.0 + t  # 1.0 → 2.0
 	elif normalized_time < 0.75:
-		# Tramonto: pomeriggio → notte
+		#Sunset: afternoon → night
 		var t: float = (normalized_time - 0.5) / 0.25
 		day_time = 2.0 + t  # 2.0 → 3.0
 	else:
-		# Notte piena
+		#Night
 		day_time = 3.0
 	
 	if weather_controller:

core/daynight/tree_leaves.gdshader

@@ -0,0 +1,122 @@
+shader_type spatial;
+render_mode specular_disabled, cull_disabled, ambient_light_disabled;
+
+global uniform float global_wind_speed;
+global uniform vec2  global_wind_direction;
+global uniform float global_wind_scale;
+global uniform float global_wind_strength;
+global uniform float global_snow_start_time;
+global uniform float global_snow_accumulation_speed;
+global uniform float global_snow_melt_time;
+global uniform float global_snow_melt_speed;
+global uniform vec4  global_snow_color;
+global uniform float global_rain_intensity;
+
+uniform sampler2D wind_noise : filter_linear_mipmap;
+uniform bool billboard_enabled = true;
+uniform bool wind_enabled = true;
+uniform vec4 base_color : source_color = vec4(0.2, 0.6, 0.3, 1.0);
+uniform sampler2D alpha_texture : source_color, filter_nearest;
+uniform float leaves_scale = 1.0;
+uniform float rotation_degrees = 0.0;
+uniform vec2 texture_offset = vec2(0.0, 0.0);
+uniform float opacity : hint_range(0.0, 1.0) = 1.0;
+uniform float height_min = 0.0;
+uniform float height_max = 5.0;
+uniform float shadow_intensity : hint_range(0.0, 1.0) = 0.5;
+uniform float highlight_intensity : hint_range(0.0, 1.0) = 0.3;
+uniform float light_steps : hint_range(1.0, 10.0) = 4.0;
+uniform float random_mix : hint_range(0.0, 1.0) = 0.3;
+uniform float cast_shadow_strength : hint_range(0.0, 1.0) = 0.6;
+uniform float wetness_darkening : hint_range(0.0, 0.5) = 0.25;
+
+varying vec3 v_final_color;
+varying float v_shade_factor;
+
+float hash(vec3 p) {
+    p = fract(p * 0.1031);
+    p += dot(p, p.yzx + 33.33);
+    return fract((p.x + p.y) * p.z);
+}
+
+void vertex() {
+    vec3 instance_pos = MODEL_MATRIX[3].xyz;
+
+    float total_angle = radians(rotation_degrees);
+    if (wind_enabled) {
+        float time = TIME * global_wind_speed;
+        vec2 noise_uv = (instance_pos.xz * global_wind_scale) + (time * global_wind_direction * 0.5);
+        float noise_val = textureLod(wind_noise, noise_uv, 2.0).r;
+        float sway = sin(time + (noise_val * 10.0));
+        total_angle += (sway * global_wind_strength);
+    }
+
+    float h_factor = clamp((instance_pos.y - height_min) / (height_max - height_min), 0.0, 1.0);
+    float leaf_rand = hash(instance_pos);
+    float combined_factor = mix(h_factor, leaf_rand, random_mix);
+    combined_factor = ceil(combined_factor * light_steps) / light_steps;
+
+    v_shade_factor = combined_factor;
+
+    vec3 dark_color  = base_color.rgb * (1.0 - shadow_intensity);
+    vec3 light_color = base_color.rgb + (vec3(1.0) - base_color.rgb) * highlight_intensity;
+    v_final_color = mix(dark_color, light_color, combined_factor);
+
+    if (billboard_enabled) {
+        vec3 view_pos_origin = (VIEW_MATRIX * vec4(instance_pos, 1.0)).xyz;
+        vec2 offset = (UV - 0.5) * leaves_scale;
+        float c = cos(total_angle);
+        float s = sin(total_angle);
+        vec2 rotated_offset = vec2(offset.x * c - offset.y * s, offset.x * s + offset.y * c);
+
+        vec3 final_pos = view_pos_origin + vec3(rotated_offset.x, rotated_offset.y, 0.0);
+        MODELVIEW_MATRIX = mat4(1.0);
+        MODELVIEW_MATRIX[3].xyz = final_pos;
+        VERTEX = vec3(0.0);
+    } else {
+        float c = cos(total_angle);
+        float s = sin(total_angle);
+        vec2 local_v = VERTEX.xy * leaves_scale;
+        VERTEX.x = local_v.x * c - local_v.y * s;
+        VERTEX.y = local_v.x * s + local_v.y * c;
+    }
+}
+
+void fragment() {
+    vec2 shifted_uv = UV + texture_offset;
+    vec4 tex = texture(alpha_texture, shifted_uv);
+
+    // Snow accumulation
+    float snow_amount = 0.0;
+    if (global_snow_start_time >= 0.0) {
+        snow_amount = clamp((TIME - global_snow_start_time) * global_snow_accumulation_speed, 0.0, 1.0);
+    }
+    if (global_snow_melt_time >= 0.0) {
+        float melt = clamp((TIME - global_snow_melt_time) * global_snow_melt_speed, 0.0, 1.0);
+        snow_amount *= (1.0 - melt);
+    }
+
+    float top_mask = 1.0 - shifted_uv.y;
+    float snow_mask = smoothstep(1.0 - snow_amount, 1.2 - snow_amount, top_mask);
+    snow_mask *= step(0.01, snow_amount);
+
+    vec3 dark_snow = global_snow_color.rgb * (1.0 - shadow_intensity);
+    vec3 shaded_snow = mix(dark_snow, global_snow_color.rgb, v_shade_factor);
+    vec3 final_albedo = mix(v_final_color, shaded_snow, snow_mask);
+
+    // Rain wetness: darken and make shinier
+    float rain_int = clamp(global_rain_intensity, 0.0, 1.0);
+    final_albedo *= mix(1.0, 1.0 - wetness_darkening, rain_int);
+    float final_roughness = mix(0.02, 0.005, rain_int);
+
+    ALBEDO = final_albedo;
+    ALPHA = tex.r * opacity;
+    ALPHA_SCISSOR_THRESHOLD = 0.5;
+    ROUGHNESS = final_roughness;
+}
+
+void light() {
+    float shadow_factor = mix(1.0 - cast_shadow_strength, 1.0, ATTENUATION);
+    float cutoff_mask = smoothstep(0.0, 0.05, ATTENUATION);
+    DIFFUSE_LIGHT += (shadow_factor * LIGHT_COLOR) * cutoff_mask;
+}

core/daynight/tree_leaves.gdshader.uid

@@ -0,0 +1 @@
+uid://cs0xl7pc6e26h

core/daynight/trunk_shader.gdshader

@@ -0,0 +1,86 @@
+shader_type spatial;
+
+render_mode diffuse_toon, specular_disabled, ambient_light_disabled;
+
+group_uniforms Albedo_Settings;
+uniform vec4 albedo_color : source_color = vec4(1.0);
+uniform sampler2D albedo_texture : source_color, filter_nearest;
+uniform bool use_texture = true;
+uniform vec2 uv_scale = vec2(1.0, 1.0);
+uniform float palette_shift_y : hint_range(0.0, 1.0) = 0.0;
+
+group_uniforms Height_Gradient;
+global uniform vec4 global_gradient_color_top; 
+global uniform vec4 global_gradient_color_bot; 
+global uniform float global_gradient_intensity; 
+
+uniform float gradient_start_y = 0.0;
+uniform float gradient_end_y = 10.0;
+
+group_uniforms Toon_Lighting;
+uniform float light_steps : hint_range(1.0, 10.0, 1.0) = 3.0;
+uniform float step_softness : hint_range(0.01, 1.0) = 0.1;
+uniform vec4 shadow_color : source_color = vec4(0.4, 0.4, 0.6, 1.0);
+uniform float shadow_offset : hint_range(-1.0, 1.0) = 0.0;
+uniform float cast_shadow_strength : hint_range(0.0, 1.0) = 0.6;
+
+group_uniforms Ghibli_Directional_Glint;
+uniform bool use_ghibli_glint = true;
+uniform vec4 glint_color : source_color = vec4(1.0, 0.95, 0.85, 1.0); 
+uniform float glint_intensity : hint_range(0.0, 10.0) = 1.0; 
+uniform float glint_sharpness : hint_range(1.0, 128.0) = 32.0; 
+
+group_uniforms Emission_Settings;
+uniform vec4 emission_color : source_color = vec4(0.0, 0.0, 0.0, 1.0);
+uniform float emission_energy : hint_range(0.0, 16.0) = 0.0;
+
+varying float world_y;
+
+void vertex() {
+	world_y = (MODEL_MATRIX * vec4(VERTEX, 1.0)).y;
+}
+
+void fragment() {
+	vec2 final_uv = (UV * uv_scale) + vec2(0.0, palette_shift_y);
+	vec4 tex = texture(albedo_texture, final_uv);
+	
+	vec3 base_color = albedo_color.rgb;
+	if (use_texture) base_color *= tex.rgb;
+	
+	float grad_factor = smoothstep(gradient_start_y, gradient_end_y, world_y);
+	vec3 current_gradient_color = mix(global_gradient_color_bot.rgb, global_gradient_color_top.rgb, grad_factor);
+	base_color = mix(base_color, current_gradient_color, global_gradient_intensity);
+	
+	ALBEDO = base_color;
+	EMISSION = emission_color.rgb * emission_energy;
+}
+
+void light() {
+	float shadow_factor = mix(1.0 - cast_shadow_strength, 1.0, ATTENUATION);
+	float cutoff_mask = smoothstep(0.0, 0.1, ATTENUATION);
+	
+	float n_dot_l = dot(NORMAL, LIGHT);
+	
+	//dither
+	float dither = fract(sin(dot(FRAGCOORD.xy, vec2(12.9898, 78.233))) * 43758.5453);
+	float intensity = (clamp(n_dot_l, 0.0, 1.0) * shadow_factor) + (dither - 0.5) * 0.02;
+	
+	float raw_step = (intensity + shadow_offset) * light_steps;
+	float lower_step = floor(raw_step);
+	float fract_step = fract(raw_step);
+	float soft_lerp = smoothstep(0.5 - step_softness, 0.5 + step_softness, fract_step);
+	float stepped_intensity = (lower_step + soft_lerp) / light_steps;
+	
+	//Toon colors
+	vec3 light_color_final = mix(shadow_color.rgb, vec3(1.1), clamp(stepped_intensity, 0.0, 1.0));
+	DIFFUSE_LIGHT += (light_color_final * LIGHT_COLOR) * cutoff_mask;
+	
+	if (use_ghibli_glint) {
+		float glint_raw = pow(max(0.0, n_dot_l), glint_sharpness);
+		float glint_mask = smoothstep(0.5 - step_softness*0.5, 0.5 + step_softness*0.5, glint_raw);
+		glint_mask *= smoothstep(0.0, 0.1, n_dot_l);
+		vec3 extra_sun_glint = glint_mask * glint_color.rgb * LIGHT_COLOR * glint_intensity * ATTENUATION;
+
+		DIFFUSE_LIGHT += extra_sun_glint;
+	}
+}

core/daynight/trunk_shader.gdshader.uid

@@ -0,0 +1 @@
+uid://d0ch5ofrgf7y6

core/daynight/weather_plain_shader.gdshader

@@ -0,0 +1,61 @@
+shader_type spatial;
+render_mode blend_mix, depth_draw_never, cull_disabled;
+
+// Snow globals
+global uniform float global_snow_start_time;
+global uniform float global_snow_accumulation_speed;
+global uniform float global_snow_melt_time;
+global uniform float global_snow_melt_speed;
+global uniform vec4  global_snow_color;
+
+// Rain globals
+global uniform float global_rain_intensity;
+
+// Snow parameters
+uniform float snow_edge_softness : hint_range(0.01, 0.5) = 0.15;
+uniform float snow_color_variation : hint_range(0.0, 0.15) = 0.05;
+
+// Rain wetness parameters
+uniform float wetness_darkening : hint_range(0.0, 0.5) = 0.25;
+uniform float wet_roughness : hint_range(0.0, 0.3) = 0.05;
+
+void fragment() {
+    // Snow accumulation
+    float snow_amount = 0.0;
+    if (global_snow_start_time >= 0.0) {
+        snow_amount = clamp((TIME - global_snow_start_time) * global_snow_accumulation_speed, 0.0, 1.0);
+    }
+    if (global_snow_melt_time >= 0.0) {
+        float melt = clamp((TIME - global_snow_melt_time) * global_snow_melt_speed, 0.0, 1.0);
+        snow_amount *= (1.0 - melt);
+    }
+
+    // UV-based snow mask: accumulates from the top of the quad
+    float top_mask = 1.0 - UV.y;
+    float snow_mask = smoothstep(1.0 - snow_amount, 1.0 - snow_amount + snow_edge_softness, top_mask);
+    snow_mask *= step(0.01, snow_amount);
+
+    // Snow color with slight variation
+    float shade = fract(sin(dot(UV, vec2(12.9898, 78.233))) * 43758.5453);
+    shade = mix(-snow_color_variation, snow_color_variation, shade);
+    vec3 snow_albedo = clamp(global_snow_color.rgb + vec3(shade), 0.0, 1.0);
+
+    // Rain wetness
+    float rain_int = clamp(global_rain_intensity, 0.0, 1.0);
+    float rain_factor = wetness_darkening * rain_int;
+
+    // Combine: snow takes priority over rain
+    if (snow_mask > rain_factor) {
+        ALBEDO = snow_albedo;
+        ROUGHNESS = 0.15;
+        METALLIC = 0.0;
+        ALPHA = snow_mask;
+    } else if (rain_int > 0.01) {
+        ALBEDO = vec3(0.0);
+        ROUGHNESS = wet_roughness;
+        METALLIC = 0.0;
+        ALPHA = rain_factor;
+    } else {
+        ALPHA = 0.0;
+    }
+}

core/daynight/weather_plain_shader.gdshader.uid

@@ -0,0 +1 @@
+uid://do8puw7u8dvry

core/daynight/weather_plain_shader.tres

@@ -0,0 +1,7 @@
+[gd_resource type="ShaderMaterial" format=3]
+
+[ext_resource type="Shader" path="res://core/daynight/weather_plain_shader.gdshader" id="1_weather_plain"]
+
+[resource]
+render_priority = 0
+shader = ExtResource("1_weather_plain")

core/environment_config.gd

@@ -2,7 +2,7 @@ class_name EnvironmentConfig
 extends Resource
 
 @export_group("Day")
-@export var day_duration: float = 120.0	#Duration of a full day cycle in seconds
+@export var day_duration: float = 300.0 #Duration of a full day cycle in seconds
 
 #Ambient light color tinting for each time of day
 @export_group("Directional Lights and Environment")