Add weather presentation and gameplay UI improvements

world/environment/local_storm_cloud.gdshader

@@ -0,0 +1,37 @@
+shader_type spatial;
+render_mode blend_mix, depth_prepass_alpha, cull_disabled, unshaded, fog_disabled, shadows_disabled;
+
+uniform vec4 cloud_color : source_color = vec4(0.07, 0.10, 0.12, 1.0);
+uniform float weather_opacity : hint_range(0.0, 1.0, 0.01) = 0.0;
+uniform float maximum_opacity : hint_range(0.0, 1.0, 0.01) = 0.5;
+uniform float distance_fade_start : hint_range(50.0, 500.0, 1.0) = 240.0;
+uniform float distance_fade_end : hint_range(50.0, 500.0, 1.0) = 300.0;
+
+varying float world_normal_height;
+varying float camera_distance;
+
+
+void vertex() {
+	world_normal_height = normalize(MODEL_NORMAL_MATRIX * NORMAL).y;
+	vec3 world_position = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
+	camera_distance = distance(
+		world_position.xz,
+		CAMERA_POSITION_WORLD.xz
+	);
+}
+
+
+void fragment() {
+	float facet_light = mix(
+		0.68,
+		1.06,
+		clamp(world_normal_height * 0.5 + 0.5, 0.0, 1.0)
+	);
+	ALBEDO = cloud_color.rgb * facet_light;
+	float distance_fade = 1.0 - smoothstep(
+		distance_fade_start,
+		distance_fade_end,
+		camera_distance
+	);
+	ALPHA = weather_opacity * maximum_opacity * distance_fade * cloud_color.a;
+}

world/environment/local_storm_cloud.gdshader.uid

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

world/environment/local_storm_cloud_layer.gd

@@ -0,0 +1,228 @@
+class_name LocalStormCloudLayer
+extends Node3D
+
+const CLOUD_SHADER: Shader = preload(
+	"res://world/environment/local_storm_cloud.gdshader"
+)
+const MIN_CLOUD_ALTITUDE: float = 15.0
+const MAX_CLOUD_ALTITUDE: float = 23.0
+const GRID_AXIS_COUNT: int = 9
+const GRID_SPACING: float = 70.0
+const FIELD_HALF_EXTENT: float = GRID_AXIS_COUNT * GRID_SPACING * 0.5
+const DISTANCE_FADE_START: float = 240.0
+const DISTANCE_FADE_END: float = 300.0
+const WRAP_RADIUS: float = FIELD_HALF_EXTENT
+const MAXIMUM_OPACITY: float = 1.0
+const BASE_VELOCITY := Vector2(0.825, -0.45)
+const BODY_OUTLINE: Array[Vector2] = [
+	Vector2(-6.9, -0.8),
+	Vector2(-6.6, -2.0),
+	Vector2(-5.7, -3.0),
+	Vector2(-4.5, -3.5),
+	Vector2(-3.0, -3.7),
+	Vector2(-1.8, -4.2),
+	Vector2(-0.5, -4.3),
+	Vector2(0.7, -4.0),
+	Vector2(2.0, -4.1),
+	Vector2(3.0, -3.5),
+	Vector2(4.6, -3.3),
+	Vector2(5.8, -2.5),
+	Vector2(6.6, -1.5),
+	Vector2(7.0, -0.2),
+	Vector2(6.8, 1.0),
+	Vector2(6.1, 1.9),
+	Vector2(6.0, 2.9),
+	Vector2(5.1, 3.7),
+	Vector2(3.8, 4.0),
+	Vector2(2.7, 4.7),
+	Vector2(1.4, 4.9),
+	Vector2(0.2, 5.3),
+	Vector2(-1.2, 5.0),
+	Vector2(-2.1, 4.4),
+	Vector2(-3.6, 4.2),
+	Vector2(-4.9, 3.5),
+	Vector2(-5.4, 2.5),
+	Vector2(-6.3, 1.7),
+	Vector2(-6.8, 0.6),
+]
+
+var _target: Node3D
+var _material: ShaderMaterial
+var _multimesh: MultiMesh
+var _cloud_mesh: MultiMeshInstance3D
+var _drift_offset := Vector2.ZERO
+var _storm_amount: float = 0.0
+
+
+func setup(target: Node3D) -> void:
+	_target = target
+	_build_cloud_field()
+	_update_cloud_transforms()
+	set_process(true)
+
+
+func set_storm_amount(amount: float, color: Color) -> void:
+	_storm_amount = clampf(amount, 0.0, 1.0)
+	var should_be_visible: bool = _storm_amount > 0.001
+	if should_be_visible and not visible:
+		_update_cloud_transforms()
+	visible = should_be_visible
+	if _material == null:
+		return
+	_material.set_shader_parameter("weather_opacity", _storm_amount)
+	_material.set_shader_parameter("cloud_color", color)
+
+
+func get_storm_amount() -> float:
+	return _storm_amount
+
+
+func get_patch_count() -> int:
+	return GRID_AXIS_COUNT * GRID_AXIS_COUNT
+
+
+func _process(delta: float) -> void:
+	if not visible or _target == null or not is_instance_valid(_target):
+		return
+	_drift_offset += BASE_VELOCITY * delta
+	_drift_offset = Vector2(
+		_wrap_axis(_drift_offset.x),
+		_wrap_axis(_drift_offset.y),
+	)
+	_update_cloud_transforms()
+
+
+func _build_cloud_field() -> void:
+	_material = ShaderMaterial.new()
+	_material.shader = CLOUD_SHADER
+	_material.set_shader_parameter("weather_opacity", 0.0)
+	_material.set_shader_parameter("maximum_opacity", MAXIMUM_OPACITY)
+	_material.set_shader_parameter("distance_fade_start", DISTANCE_FADE_START)
+	_material.set_shader_parameter("distance_fade_end", DISTANCE_FADE_END)
+
+	var cloud_body_mesh: ArrayMesh = _build_cloud_body_mesh()
+	cloud_body_mesh.surface_set_material(0, _material)
+
+	_multimesh = MultiMesh.new()
+	_multimesh.transform_format = MultiMesh.TRANSFORM_3D
+	_multimesh.mesh = cloud_body_mesh
+	_multimesh.instance_count = get_patch_count()
+	_multimesh.custom_aabb = AABB(
+		Vector3(
+			-FIELD_HALF_EXTENT - 60.0,
+			MIN_CLOUD_ALTITUDE - 5.0,
+			-FIELD_HALF_EXTENT - 60.0,
+		),
+		Vector3(
+			(FIELD_HALF_EXTENT + 60.0) * 2.0,
+			MAX_CLOUD_ALTITUDE - MIN_CLOUD_ALTITUDE + 10.0,
+			(FIELD_HALF_EXTENT + 60.0) * 2.0,
+		),
+	)
+
+	_cloud_mesh = MultiMeshInstance3D.new()
+	_cloud_mesh.name = "CloudField"
+	_cloud_mesh.multimesh = _multimesh
+	_cloud_mesh.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
+	add_child(_cloud_mesh)
+	visible = false
+
+
+func _build_cloud_body_mesh() -> ArrayMesh:
+	var outline := PackedVector2Array(BODY_OUTLINE)
+	var surface_tool := SurfaceTool.new()
+	surface_tool.begin(Mesh.PRIMITIVE_TRIANGLES)
+	var face_indices: PackedInt32Array = Geometry2D.triangulate_polygon(
+		outline
+	)
+	for triangle_offset: int in range(0, face_indices.size(), 3):
+		var point_a: Vector2 = outline[face_indices[triangle_offset]]
+		var point_b: Vector2 = outline[face_indices[triangle_offset + 1]]
+		var point_c: Vector2 = outline[face_indices[triangle_offset + 2]]
+		_add_oriented_triangle(
+			surface_tool,
+			_to_cloud_vertex(point_a),
+			_to_cloud_vertex(point_b),
+			_to_cloud_vertex(point_c),
+			Vector3.DOWN,
+		)
+	surface_tool.index()
+	return surface_tool.commit()
+
+
+func _to_cloud_vertex(point: Vector2) -> Vector3:
+	return Vector3(point.x, 0.0, point.y)
+
+
+func _add_oriented_triangle(
+	surface_tool: SurfaceTool,
+	point_a: Vector3,
+	point_b: Vector3,
+	point_c: Vector3,
+	expected_normal: Vector3,
+) -> void:
+	if (point_b - point_a).cross(point_c - point_a).dot(expected_normal) < 0.0:
+		var swap: Vector3 = point_b
+		point_b = point_c
+		point_c = swap
+	for point: Vector3 in [point_a, point_b, point_c]:
+		surface_tool.set_normal(expected_normal)
+		surface_tool.add_vertex(point)
+
+
+func _update_cloud_transforms() -> void:
+	if _target == null or _multimesh == null:
+		return
+	global_position = _target.global_position
+	var target_xz := Vector2(
+		_target.global_position.x,
+		_target.global_position.z,
+	)
+	var grid_center: float = float(GRID_AXIS_COUNT - 1) * 0.5
+	var instance_index: int = 0
+	for grid_z: int in GRID_AXIS_COUNT:
+		for grid_x: int in GRID_AXIS_COUNT:
+			var patch_index: int = grid_z * GRID_AXIS_COUNT + grid_x
+			var world_offset := Vector2(
+				(float(grid_x) - grid_center) * GRID_SPACING,
+				(float(grid_z) - grid_center) * GRID_SPACING,
+			) + _drift_offset
+			var relative := Vector2(
+				_wrap_axis(world_offset.x - target_xz.x),
+				_wrap_axis(world_offset.y - target_xz.y),
+			)
+			var altitude: float = lerpf(
+				MIN_CLOUD_ALTITUDE,
+				MAX_CLOUD_ALTITUDE,
+				float(patch_index % 4) / 3.0,
+			)
+			var patch_scale: float = 2.20 + float(
+				(patch_index * 7) % 10
+			) * 0.10
+			var width_variation: float = 0.90 + float(
+				(patch_index * 5) % 7
+			) * 0.04
+			var depth_variation: float = 0.90 + float(
+				(patch_index * 3 + 2) % 7
+			) * 0.04
+			var patch_basis := Basis(
+				Vector3.UP,
+				deg_to_rad(float(patch_index * 17 % 41) - 20.0),
+			).scaled(Vector3(
+				patch_scale * 2.35 * width_variation,
+				patch_scale * 0.34,
+				patch_scale * 2.65 * depth_variation,
+			))
+			_multimesh.set_instance_transform(
+				instance_index,
+				Transform3D(
+					patch_basis,
+					Vector3(relative.x, altitude, relative.y),
+				),
+			)
+			instance_index += 1
+
+
+func _wrap_axis(value: float) -> float:
+	return fposmod(value + FIELD_HALF_EXTENT, FIELD_HALF_EXTENT * 2.0) \
+		- FIELD_HALF_EXTENT

world/environment/local_storm_cloud_layer.gd.uid

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

world/environment/netfishing_environment.tres

@@ -10,7 +10,7 @@ ambient_light_source = 2
 ambient_light_color = Color(0.82, 0.9, 0.92, 1)
 ambient_light_energy = 1.08
 reflected_light_source = 2
-fog_enabled = true
+fog_enabled = false
 fog_mode = 1
 fog_light_color = Color(0.54902, 0.74902, 0.764706, 1)
 fog_light_energy = 0.82

world/environment/netfishing_sky.gdshader

@@ -1,5 +1,7 @@
 shader_type sky;
 
+#include "res://world/environment/netfishing_sky_clouds.gdshaderinc"
+
 uniform vec4 sky_top_color : source_color = vec4(0.204, 0.498, 0.643, 1.0);
 uniform vec4 sky_horizon_color : source_color = vec4(0.663, 0.843, 0.847, 1.0);
 uniform vec4 ground_bottom_color : source_color = vec4(0.157, 0.361, 0.439, 1.0);
@@ -83,6 +85,7 @@ void sky() {
 	base_color = mix(
 		base_color, moon_color.rgb, moon_disc * moon_visible_strength
 	);
+	base_color = apply_weather_clouds(base_color, view_direction);
 
 	COLOR = base_color;
 }

world/environment/netfishing_sky_clouds.gdshaderinc

@@ -0,0 +1,70 @@
+uniform float cloud_coverage : hint_range(0.0, 1.0, 0.01) = 0.0;
+uniform float cloud_opacity : hint_range(0.0, 1.0, 0.01) = 0.0;
+uniform vec4 cloud_light_color : source_color = vec4(0.70, 0.76, 0.77, 1.0);
+uniform vec4 cloud_shadow_color : source_color = vec4(0.31, 0.38, 0.40, 1.0);
+uniform vec2 cloud_wind = vec2(0.010, -0.006);
+uniform float cloud_scale : hint_range(0.1, 3.0, 0.05) = 0.72;
+
+
+float cloud_hash(vec2 point) {
+	return fract(sin(dot(point, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+
+float cloud_value_noise(vec2 point) {
+	vec2 cell = floor(point);
+	vec2 local = fract(point);
+	vec2 blend = local * local * (3.0 - 2.0 * local);
+	float bottom = mix(
+		cloud_hash(cell),
+		cloud_hash(cell + vec2(1.0, 0.0)),
+		blend.x
+	);
+	float top = mix(
+		cloud_hash(cell + vec2(0.0, 1.0)),
+		cloud_hash(cell + vec2(1.0, 1.0)),
+		blend.x
+	);
+	return mix(bottom, top, blend.y);
+}
+
+
+float cloud_shape(vec2 point) {
+	vec2 broad_point = floor(point * 5.0) / 5.0;
+	vec2 detail_point = floor(point * 13.0) / 13.0;
+	float broad = cloud_value_noise(broad_point * 0.62);
+	float detail = cloud_value_noise(detail_point * 1.55 + vec2(17.3, 9.1));
+	float combined = broad * 0.72 + detail * 0.28;
+	return floor(combined * 7.0 + 0.5) / 7.0;
+}
+
+
+vec3 apply_weather_clouds(vec3 base_color, vec3 view_direction) {
+	if (cloud_opacity <= 0.001 || view_direction.y <= 0.0) {
+		return base_color;
+	}
+	float safe_height = max(view_direction.y, 0.08);
+	vec2 cloud_plane = view_direction.xz / safe_height;
+	vec2 cloud_point = (
+		cloud_plane + cloud_wind * TIME
+	) * cloud_scale;
+	float shape = cloud_shape(cloud_point);
+	float threshold = mix(0.82, 0.27, cloud_coverage);
+	float mask = smoothstep(threshold - 0.08, threshold + 0.08, shape);
+	mask = floor(mask * 4.0 + 0.5) / 4.0;
+	mask *= smoothstep(0.025, 0.14, view_direction.y);
+	mask *= cloud_opacity;
+	float body_depth = smoothstep(threshold, 1.0, shape);
+	float underside = clamp(
+		(1.0 - smoothstep(0.08, 0.72, view_direction.y)) * 0.35
+		+ body_depth * 0.65,
+		0.0,
+		1.0
+	);
+	vec3 cloud_color = mix(
+		cloud_light_color.rgb,
+		cloud_shadow_color.rgb,
+		underside
+	);
+	return mix(base_color, cloud_color, mask);
+}

world/environment/netfishing_sky_clouds.gdshaderinc.uid

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