jmp-games/tgcc
5
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix materials for wind and add new snow system

Browse Source
This commit is contained in:
Overside srl
2026-04-24 15:36:10 +02:00
parent ab87c7f478
commit 211455f5da
18 changed files with 364 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
core/daynight/snow_cap.gd Normal file
View File

@@ -0,0 +1,114 @@
## Procedural snow cap geometry for flat roofs and vehicles.
extends Node3D
enum PlacementMode {
AUTO_TARGET_AABB,
MANUAL_SURFACE,
}
const SNOW_CAP_SHADER: Shader = preload("res://core/daynight/snow_cap.gdshader")
@export var placement_mode: PlacementMode = PlacementMode.AUTO_TARGET_AABB
@export var target_path: NodePath
@export var size_inset: Vector2 = Vector2(0.25, 1.0)
@export var position_offset: Vector3 = Vector3(0.0, -0.08, 0.0)
@export var max_snow_height: float = 0.2
@export_range(1, 24) var subdivide_width: int = 6
@export_range(1, 24) var subdivide_depth: int = 18
@export var manual_surface_center: Vector3 = Vector3.ZERO
@export var manual_surface_size: Vector2 = Vector2(2.0, 6.0)
var _mesh_instance: MeshInstance3D
func _ready() -> void:
add_to_group("weather_overlay_ignore")
_ensure_mesh_instance()
_rebuild()
func rebuild() -> void:
_rebuild()
func _ensure_mesh_instance() -> void:
_mesh_instance = get_node_or_null("SnowCapMesh") as MeshInstance3D
if _mesh_instance != null:
return
_mesh_instance = MeshInstance3D.new()
_mesh_instance.name = "SnowCapMesh"
_mesh_instance.add_to_group("weather_overlay_ignore")
add_child(_mesh_instance)
func _rebuild() -> void:
var cap_width: float = 0.0
var cap_depth: float = 0.0
var cap_surface_center := Vector3.ZERO
if placement_mode == PlacementMode.MANUAL_SURFACE:
cap_width = manual_surface_size.x
cap_depth = manual_surface_size.y
cap_surface_center = manual_surface_center
else:
var target_mesh: MeshInstance3D = get_node_or_null(target_path) as MeshInstance3D
if target_mesh == null:
if _mesh_instance:
_mesh_instance.visible = false
return
var target_aabb: AABB = _get_target_aabb(target_mesh)
cap_width = max(target_aabb.size.x - size_inset.x, 0.1)
cap_depth = max(target_aabb.size.z - size_inset.y, 0.1)
cap_surface_center = Vector3(
target_aabb.position.x + target_aabb.size.x * 0.5,
target_aabb.position.y + target_aabb.size.y,
target_aabb.position.z + target_aabb.size.z * 0.5
)
var cap_center := cap_surface_center + Vector3(0.0, max_snow_height * 0.5, 0.0)
var box_mesh := BoxMesh.new()
box_mesh.size = Vector3(cap_width, max_snow_height, cap_depth)
box_mesh.subdivide_width = subdivide_width
box_mesh.subdivide_depth = subdivide_depth
_mesh_instance.mesh = box_mesh
_mesh_instance.position = cap_center + position_offset
_mesh_instance.material_override = _build_material(cap_width, cap_depth)
_mesh_instance.visible = true
func _build_material(cap_width: float, cap_depth: float) -> ShaderMaterial:
var material := ShaderMaterial.new()
material.shader = SNOW_CAP_SHADER
material.set_shader_parameter("max_height", max_snow_height)
material.set_shader_parameter("half_width", cap_width * 0.5)
material.set_shader_parameter("half_depth", cap_depth * 0.5)
return material
func _get_target_aabb(target_mesh: MeshInstance3D) -> AABB:
var points: Array[Vector3] = []
for point in _get_aabb_points(target_mesh.get_aabb()):
points.append(target_mesh.transform * point)
var merged := AABB(points[0], Vector3.ZERO)
for point in points:
merged = merged.expand(point)
return merged
func _get_aabb_points(aabb: AABB) -> Array[Vector3]:
var p: Vector3 = aabb.position
var s: Vector3 = aabb.size
return [
p,
p + Vector3(s.x, 0.0, 0.0),
p + Vector3(0.0, s.y, 0.0),
p + Vector3(0.0, 0.0, s.z),
p + Vector3(s.x, s.y, 0.0),
p + Vector3(s.x, 0.0, s.z),
p + Vector3(0.0, s.y, s.z),
p + s,
]

1
core/daynight/snow_cap.gd.uid Normal file
View File

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

114
core/daynight/snow_cap.gdshader Normal file
View File

@@ -0,0 +1,114 @@
shader_type spatial;
render_mode blend_mix, cull_back, depth_draw_opaque;
global uniform float global_snow_start_time = -1.0;
global uniform float global_snow_accumulation_speed = 0.1;
global uniform float global_snow_melt_time = -1.0;
global uniform float global_snow_melt_speed = 0.1;
global uniform vec4 global_snow_color = vec4(0.92, 0.96, 1.0, 1.0);
uniform float max_height : hint_range(0.02, 1.0) = 0.2;
uniform float half_width : hint_range(0.01, 20.0) = 1.0;
uniform float half_depth : hint_range(0.01, 20.0) = 1.0;
uniform float noise_scale : hint_range(0.05, 2.0) = 0.35;
uniform float noise_strength : hint_range(0.0, 0.4) = 0.18;
uniform float edge_rounding : hint_range(0.0, 0.3) = 0.12;
uniform float side_shade : hint_range(0.2, 1.0) = 0.82;
uniform float sparkle_strength : hint_range(0.0, 0.1) = 0.03;
varying float v_snow_amount;
varying float v_noise;
float hash(vec2 p) {
return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
}
float value_noise(vec2 p) {
vec2 i = floor(p);
vec2 f = fract(p);
vec2 u = f * f * (3.0 - 2.0 * f);
float a = hash(i);
float b = hash(i + vec2(1.0, 0.0));
float c = hash(i + vec2(0.0, 1.0));
float d = hash(i + vec2(1.0, 1.0));
return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
}
float fbm(vec2 p) {
float value = 0.0;
float amplitude = 0.5;
float frequency = 1.0;
for (int i = 0; i < 4; i++) {
value += value_noise(p * frequency) * amplitude;
frequency *= 2.0;
amplitude *= 0.5;
}
return clamp(value, 0.0, 1.0);
}
float get_snow_amount() {
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);
}
return snow_amount;
}
void vertex() {
vec3 base_vertex = VERTEX;
vec3 world_pos = (MODEL_MATRIX * vec4(base_vertex, 1.0)).xyz;
float snow_amount = get_snow_amount();
float noise_val = fbm(world_pos.xz * noise_scale);
float thickness = max_height * snow_amount * mix(
1.0 - noise_strength,
1.0 + noise_strength,
noise_val
);
float footprint_growth = smoothstep(0.0, 0.35, snow_amount);
float from_bottom = clamp((base_vertex.y + max_height * 0.5) / max_height, 0.0, 1.0);
VERTEX.y = -max_height * 0.5 + thickness * from_bottom;
VERTEX.x *= mix(0.92, 1.0, footprint_growth);
VERTEX.z *= mix(0.94, 1.0, footprint_growth);
float edge_x = abs(base_vertex.x) / max(half_width, 0.001);
float edge_z = abs(base_vertex.z) / max(half_depth, 0.001);
float edge_mask = smoothstep(0.55, 1.0, max(edge_x, edge_z));
float top_mask = smoothstep(0.6, 1.0, from_bottom) * snow_amount;
float round_factor = edge_rounding * edge_mask * top_mask;
VERTEX.x *= 1.0 - round_factor;
VERTEX.z *= 1.0 - round_factor;
v_snow_amount = snow_amount;
v_noise = noise_val;
}
void fragment() {
if (v_snow_amount <= 0.001) {
ALPHA = 0.0;
ALBEDO = global_snow_color.rgb;
ROUGHNESS = 1.0;
SPECULAR = 0.0;
} else {
float facing_up = clamp(NORMAL.y, 0.0, 1.0);
float shade = mix(-sparkle_strength, sparkle_strength, v_noise);
vec3 snow_albedo = clamp(global_snow_color.rgb + vec3(shade), 0.0, 1.0);
ALBEDO = mix(snow_albedo * side_shade, snow_albedo, facing_up);
ROUGHNESS = mix(0.95, 0.72, facing_up);
SPECULAR = 0.18;
ALPHA = smoothstep(0.0, 0.28, v_snow_amount);
}
}

1
core/daynight/snow_cap.gdshader.uid Normal file
View File

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

6
core/daynight/weather_controller.gd
View File

@@ -699,6 +699,12 @@ func init_snow(value: float = 0.0):
RenderingServer.global_shader_parameter_set("global_snow_color", environment_config.snow_color)
RenderingServer.global_shader_parameter_set("global_snow_accumulation_speed", environment_config.snow_accumulation_speed)
RenderingServer.global_shader_parameter_set("global_snow_melt_speed", environment_config.snow_melt_speed)
RenderingServer.global_shader_parameter_set("global_snow_max_accumulation", environment_config.snow_max_accumulation)
RenderingServer.global_shader_parameter_set("global_snow_cap_height", environment_config.snow_cap_height)
RenderingServer.global_shader_parameter_set("global_snow_cap_flatness_start", environment_config.snow_cap_flatness_start)
RenderingServer.global_shader_parameter_set("global_snow_cap_flatness_end", environment_config.snow_cap_flatness_end)
RenderingServer.global_shader_parameter_set("global_snow_cap_noise_scale", environment_config.snow_cap_noise_scale)
RenderingServer.global_shader_parameter_set("global_snow_cap_noise_strength", environment_config.snow_cap_noise_strength)
RenderingServer.global_shader_parameter_set("global_snow_start_time", -1.0)
RenderingServer.global_shader_parameter_set("global_snow_melt_time", -1.0)

91
core/daynight/weather_overlay.gdshader
View File

@@ -8,6 +8,12 @@ global uniform float global_snow_melt_time = -1.0;
global uniform float global_snow_melt_speed = 0.1;
global uniform float global_snow_threshold = 0.5;
global uniform vec4 global_snow_color = vec4(0.92, 0.96, 1.0, 1.0);
global uniform float global_snow_max_accumulation = 0.72;
global uniform float global_snow_cap_height = 0.06;
global uniform float global_snow_cap_flatness_start = 0.72;
global uniform float global_snow_cap_flatness_end = 0.96;
global uniform float global_snow_cap_noise_scale = 0.22;
global uniform float global_snow_cap_noise_strength = 0.18;
uniform float snow_noise_scale : hint_range(0.01, 1.0) = 0.15;
uniform float snow_edge_softness : hint_range(0.01, 0.5) = 0.2;
uniform float snow_roughness_variation : hint_range(0.0, 0.3) = 0.15;
@@ -29,6 +35,52 @@ uniform float puddle_threshold : hint_range(0.0, 0.8) = 0.45;
uniform sampler2D noise_texture : filter_linear_mipmap, repeat_enable;
varying float v_snow_amount;
varying float v_snow_cap_mask;
float hash(vec2 p) {
return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
}
float value_noise(vec2 p) {
vec2 i = floor(p);
vec2 f = fract(p);
vec2 u = f * f * (3.0 - 2.0 * f);
float a = hash(i);
float b = hash(i + vec2(1.0, 0.0));
float c = hash(i + vec2(0.0, 1.0));
float d = hash(i + vec2(1.0, 1.0));
return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
}
float fbm(vec2 p) {
float value = 0.0;
float amplitude = 0.5;
float frequency = 1.0;
for (int i = 0; i < 3; i++) {
value += value_noise(p * frequency) * amplitude;
frequency *= 2.0;
amplitude *= 0.5;
}
return clamp(value, 0.0, 1.0);
}
float get_snow_amount() {
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);
}
return snow_amount * global_snow_max_accumulation;
}
float ripple_ring(vec2 uv, float time_offset) {
float d = length(uv);
float ring = sin(d * 30.0 - TIME * ripple_speed + time_offset) * 0.5 + 0.5;
@@ -36,6 +88,26 @@ float ripple_ring(vec2 uv, float time_offset) {
return ring * fade;
}
void vertex() {
float snow_amount = get_snow_amount();
vec3 world_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
vec3 world_normal = normalize((MODEL_MATRIX * vec4(NORMAL, 0.0)).xyz);
float flat_surface = smoothstep(
max(global_snow_threshold, global_snow_cap_flatness_start),
global_snow_cap_flatness_end,
world_normal.y
);
float accumulation_growth = smoothstep(0.08, 0.65, snow_amount);
float cap_noise = fbm(world_pos.xz * global_snow_cap_noise_scale + vec2(11.3, 4.7));
float cap_variation = mix(1.0 - global_snow_cap_noise_strength, 1.0 + global_snow_cap_noise_strength, cap_noise);
v_snow_amount = snow_amount;
v_snow_cap_mask = flat_surface * accumulation_growth * cap_variation;
VERTEX += NORMAL * (global_snow_cap_height * snow_amount * v_snow_cap_mask);
}
void fragment() {
vec3 world_pos = (INV_VIEW_MATRIX * vec4(VERTEX, 1.0)).xyz;
vec3 world_normal = normalize((INV_VIEW_MATRIX * vec4(NORMAL, 0.0)).xyz);
@@ -43,25 +115,22 @@ void fragment() {
float noise_val = texture(noise_texture, world_pos.xz * snow_noise_scale).r;
//Snow
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 snow_amount = v_snow_amount;
float snow_edge = smoothstep(
global_snow_threshold - snow_edge_softness,
global_snow_threshold + snow_edge_softness,
facing_up + (noise_val - 0.5) * 0.4
);
float snow_coverage = smoothstep(0.0, 0.6, noise_val + snow_amount - 0.4);
float snow_factor = snow_edge * snow_coverage * snow_amount;
float flat_accumulation = smoothstep(0.0, 0.35, v_snow_cap_mask) * snow_amount;
float snow_coverage = smoothstep(0.0, 0.6, noise_val + snow_amount - 0.4 + flat_accumulation * 0.25);
float snow_factor = max(snow_edge * snow_coverage * snow_amount, flat_accumulation);
float snow_opacity = smoothstep(0.04, 0.28, snow_factor);
snow_opacity = max(snow_opacity, flat_accumulation * 0.9);
float shade = mix(-snow_color_variation, snow_color_variation, noise_val);
vec3 snow_albedo = clamp(global_snow_color.rgb + vec3(shade), 0.0, 1.0);
snow_albedo = mix(snow_albedo, vec3(1.0), 0.18 + snow_opacity * 0.12);
float snow_rough = mix(0.15 - snow_roughness_variation, 0.15 + snow_roughness_variation, noise_val);
//Rain
@@ -173,7 +242,7 @@ void fragment() {
ALBEDO = snow_albedo;
ROUGHNESS = snow_rough;
METALLIC = 0.0;
ALPHA = snow_factor;
ALPHA = snow_opacity;
} else {
ALBEDO = rain_albedo;
ROUGHNESS = rain_rough;

14
core/daynight/weather_overlay.tres
View File

@@ -5,17 +5,3 @@
[resource]
render_priority = 0
shader = ExtResource("1_weather")
shader_parameter/snow_noise_scale = 0.15
shader_parameter/snow_edge_softness = 0.2
shader_parameter/snow_roughness_variation = 0.15
shader_parameter/snow_color_variation = 0.05
shader_parameter/ripple_scale = 1.5
shader_parameter/ripple_speed = 2.0
shader_parameter/ripple_layers = 3.0
shader_parameter/streak_scale = 2.0
shader_parameter/streak_speed = 0.8
shader_parameter/wetness_darkening = 0.25
shader_parameter/wet_roughness = 0.05
shader_parameter/rain_normal_strength = 0.4
shader_parameter/puddle_noise_scale = 0.08
shader_parameter/puddle_threshold = 0.45

9
core/daynight/weather_plain_shader.gdshader
View File

@@ -7,16 +7,13 @@ 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;
global uniform float global_rain_puddle_amount;
// 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
global uniform float global_rain_intensity;
global uniform float global_rain_puddle_amount;
uniform float ripple_scale : hint_range(0.1, 5.0) = 1.5;
uniform float ripple_speed : hint_range(0.5, 5.0) = 2.0;
uniform float ripple_layers : hint_range(1.0, 4.0) = 3.0;

10
core/environment_config.gd
View File

@@ -139,9 +139,15 @@ extends Resource
@export var snow_transaction_time: float = 10.0 #Seconds for snow shader to fully transition in/out
@export var snow_fade_time: float = 5.0 #Seconds for snow particles to fade in/out
@export var snow_threshold: float = 0.4 #Normal Y threshold for snow accumulation on surfaces
@export var snow_accumulation_speed: float = 0.02 #Accumulation speed: 0.1 -> 10s, 0.05 -> 20s, 0.02 -> 50s, 0.2 -> 5s
@export var snow_accumulation_speed: float = 0.018 #Accumulation speed: 0.1 -> 10s, 0.05 -> 20s, 0.02 -> 50s, 0.012 -> ~83s
@export var snow_melt_speed: float = 0.05 #Speed at which accumulated snow melts away
@export var snow_max_accumulation: float = 0.3 #Maximum accumulated snow factor applied to coverage and thickness
@export var snow_color: Color = Color(0.9, 0.95, 1.0) #Albedo color of snow on surfaces
@export var snow_cap_height: float = 0.03 #Maximum snow thickness extruded on flat surfaces
@export var snow_cap_flatness_start: float = 0.85 #Surface normal Y where cap buildup starts
@export var snow_cap_flatness_end: float = 0.96 #Surface normal Y where cap buildup reaches full effect
@export var snow_cap_noise_scale: float = 0.22 #Noise scale used to vary the snow cap silhouette
@export var snow_cap_noise_strength: float = 0.12 #How much the cap noise changes the accumulated thickness
@export var snow_mode_color: Color = Color(0.556, 0.62, 0.683, 1.0) #Sky/light darkening color during snow
#Wind settings
@@ -152,7 +158,7 @@ extends Resource
@export var wind_direction: Vector2 = Vector2(0.5, 0.4) #Global wind direction (XZ)
@export var wind_speed: float = 0.2 #Global wind animation speed
@export var wind_scale: float = 0.025 #Global wind noise scale
@export var wind_strength: float = 0.6 #Global wind displacement strength
@export var wind_strength: float = 0.3 #Global wind displacement strength
@export var cloud_scale: float = 0.5 #Cloud noise scale in sky shader
@export var cloud_speed: float = 0.05 #Cloud movement speed in sky shader
@export_range(0.01, 1.0) var cloud_scale_envshadows_rate: float = 0.01 #Cloud scale multiplier for environment shadows