592 lines
17 KiB
GDScript
592 lines
17 KiB
GDScript
class_name WorldTimeVisualController
|
|
extends Node
|
|
|
|
const UPDATE_INTERVAL_SECONDS: float = 0.1
|
|
const SUN_YAW_DEGREES: float = -32.0
|
|
const WEATHER_TRANSITION_SECONDS: float = 10.0
|
|
const RAIN_EMITTER_OFFSET := Vector3(0.0, 7.0, 0.0)
|
|
const RAIN_PARTICLE_AMOUNT: int = 560
|
|
const RAIN_VELOCITY_MIN: float = 16.0
|
|
const RAIN_VELOCITY_MAX: float = 20.0
|
|
const RAIN_DROP_SIZE := Vector3(0.014, 0.34, 0.014)
|
|
const FOG_DAYLIGHT_SCENE_BRIGHTNESS: float = 0.42
|
|
const FOG_DAYLIGHT_FOG_LIGHT_BRIGHTNESS: float = 0.42
|
|
const FOG_DAYLIGHT_WATER_BRIGHTNESS: float = 0.42
|
|
const FOG_DAYLIGHT_POST_BRIGHTNESS: float = 0.50
|
|
const RAIN_DAYLIGHT_POST_BRIGHTNESS: float = 0.52
|
|
const RAIN_WATER_FOG_COLOR := Color(0.025, 0.038, 0.045)
|
|
const SALT_WATER_MATERIAL: ShaderMaterial = preload(
|
|
"res://world/materials/stylized_water.tres"
|
|
)
|
|
const FRESH_WATER_MATERIAL: ShaderMaterial = preload(
|
|
"res://world/materials/stylized_water_fresh.tres"
|
|
)
|
|
const LocalStormCloudLayerType = preload(
|
|
"res://world/environment/local_storm_cloud_layer.gd"
|
|
)
|
|
|
|
const DAY_SKY_TOP := Color(0.204, 0.498, 0.643)
|
|
const DAY_SKY_HORIZON := Color(0.663, 0.843, 0.847)
|
|
const DAY_GROUND_BOTTOM := Color(0.157, 0.361, 0.439)
|
|
const DAY_GROUND_HORIZON := Color(0.549, 0.749, 0.765)
|
|
const DAY_AMBIENT := Color(0.82, 0.90, 0.92)
|
|
const DAY_FOG := Color(0.549, 0.749, 0.765)
|
|
const DAY_SUN := Color(0.88, 0.94, 0.96)
|
|
const DAY_SUN_DISC := Color(1.0, 0.86, 0.46)
|
|
|
|
const NIGHT_SKY_TOP := Color(0.026, 0.050, 0.105)
|
|
const NIGHT_SKY_HORIZON := Color(0.10, 0.17, 0.28)
|
|
const NIGHT_GROUND_BOTTOM := Color(0.020, 0.040, 0.080)
|
|
const NIGHT_GROUND_HORIZON := Color(0.075, 0.135, 0.22)
|
|
const NIGHT_AMBIENT := Color(0.28, 0.35, 0.48)
|
|
const NIGHT_FOG := Color(0.13, 0.21, 0.32)
|
|
const NIGHT_SUN := Color(0.35, 0.44, 0.62)
|
|
const NIGHT_WATER_TINT := Color(0.34, 0.48, 0.58)
|
|
|
|
const WARM_SKY_TOP := Color(0.31, 0.30, 0.42)
|
|
const WARM_SKY_HORIZON := Color(0.96, 0.48, 0.22)
|
|
const WARM_GROUND_BOTTOM := Color(0.20, 0.14, 0.16)
|
|
const WARM_GROUND_HORIZON := Color(0.82, 0.34, 0.18)
|
|
const WARM_AMBIENT := Color(0.92, 0.58, 0.40)
|
|
const WARM_FOG := Color(0.74, 0.39, 0.27)
|
|
const WARM_SUN := Color(1.0, 0.58, 0.30)
|
|
const WARM_WATER_TINT := Color(0.78, 0.62, 0.58)
|
|
const WARM_SUN_DISC := Color(1.0, 0.45, 0.16)
|
|
const MOON_DISC := Color(0.78, 0.88, 1.0)
|
|
const DAY_CLOUD_LIGHT := Color(0.70, 0.76, 0.77)
|
|
const DAY_CLOUD_SHADOW := Color(0.31, 0.38, 0.40)
|
|
const NIGHT_CLOUD_LIGHT := Color(0.18, 0.22, 0.30)
|
|
const NIGHT_CLOUD_SHADOW := Color(0.06, 0.09, 0.14)
|
|
const WARM_CLOUD_LIGHT := Color(0.76, 0.55, 0.45)
|
|
const WARM_CLOUD_SHADOW := Color(0.31, 0.23, 0.24)
|
|
const STORM_CLOUD_SHADOW := Color(0.08, 0.12, 0.14)
|
|
const DAY_LOWER_CLOUD := Color(0.22, 0.25, 0.26)
|
|
const NIGHT_LOWER_CLOUD := Color(0.08, 0.10, 0.14)
|
|
const WARM_LOWER_CLOUD := Color(0.22, 0.16, 0.16)
|
|
|
|
var _time_service: WorldTimeService
|
|
var _weather_service: WorldWeatherService
|
|
var _world_environment: WorldEnvironment
|
|
var _sun: DirectionalLight3D
|
|
var _rain_target: Node3D
|
|
var _rain_camera_provider: Callable
|
|
var _environment: Environment
|
|
var _sky_material: ShaderMaterial
|
|
var _rain: GPUParticles3D
|
|
var _storm_clouds: LocalStormCloudLayer
|
|
var _elapsed: float = 0.0
|
|
var _weather_from: WorldWeatherService.Weather = (
|
|
WorldWeatherService.Weather.SUNNY
|
|
)
|
|
var _weather_to: WorldWeatherService.Weather = (
|
|
WorldWeatherService.Weather.SUNNY
|
|
)
|
|
var _weather_transition: float = 1.0
|
|
|
|
|
|
func setup(
|
|
time_service: WorldTimeService,
|
|
world_environment: WorldEnvironment,
|
|
sun: DirectionalLight3D,
|
|
weather_service: WorldWeatherService = null,
|
|
rain_target: Node3D = null,
|
|
rain_camera_provider: Callable = Callable(),
|
|
) -> void:
|
|
_time_service = time_service
|
|
_weather_service = weather_service
|
|
_world_environment = world_environment
|
|
_sun = sun
|
|
_rain_target = rain_target
|
|
_rain_camera_provider = rain_camera_provider
|
|
if not _prepare_runtime_environment():
|
|
set_process(false)
|
|
return
|
|
_prepare_rain()
|
|
_prepare_storm_clouds()
|
|
if _weather_service != null:
|
|
_weather_from = _weather_service.get_weather()
|
|
_weather_to = _weather_from
|
|
_weather_transition = 1.0
|
|
if not _weather_service.weather_changed.is_connected(
|
|
_on_weather_changed
|
|
):
|
|
_weather_service.weather_changed.connect(_on_weather_changed)
|
|
set_process(true)
|
|
_apply_time(_time_service.get_time_hours())
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if _time_service == null:
|
|
return
|
|
_update_rain_position()
|
|
if _weather_transition < 1.0:
|
|
_weather_transition = minf(
|
|
_weather_transition + delta / WEATHER_TRANSITION_SECONDS,
|
|
1.0,
|
|
)
|
|
_elapsed += delta
|
|
if _elapsed < UPDATE_INTERVAL_SECONDS:
|
|
return
|
|
_elapsed = 0.0
|
|
_apply_time(_time_service.get_time_hours())
|
|
|
|
|
|
func apply_time_immediately(time_hours: float) -> void:
|
|
_apply_time(time_hours)
|
|
|
|
|
|
func apply_weather_immediately(
|
|
weather: WorldWeatherService.Weather,
|
|
) -> void:
|
|
_weather_from = weather
|
|
_weather_to = weather
|
|
_weather_transition = 1.0
|
|
if _time_service != null:
|
|
_apply_time(_time_service.get_time_hours())
|
|
|
|
|
|
func _prepare_runtime_environment() -> bool:
|
|
if (
|
|
_time_service == null
|
|
or _world_environment == null
|
|
or _world_environment.environment == null
|
|
or _sun == null
|
|
):
|
|
push_error("World time visuals require an environment and sun.")
|
|
return false
|
|
_environment = _world_environment.environment.duplicate(true) as Environment
|
|
if _environment == null or _environment.sky == null:
|
|
push_error("World time visuals could not duplicate the world environment.")
|
|
return false
|
|
var runtime_sky: Sky = _environment.sky.duplicate(true) as Sky
|
|
if runtime_sky == null or runtime_sky.sky_material == null:
|
|
push_error("World time visuals require a sky material.")
|
|
return false
|
|
_sky_material = (
|
|
runtime_sky.sky_material.duplicate(true) as ShaderMaterial
|
|
)
|
|
if _sky_material == null:
|
|
push_error("World time visuals require the NETfishing sky material.")
|
|
return false
|
|
runtime_sky.sky_material = _sky_material
|
|
_environment.sky = runtime_sky
|
|
_world_environment.environment = _environment
|
|
return true
|
|
|
|
|
|
func _prepare_rain() -> void:
|
|
_rain = GPUParticles3D.new()
|
|
_rain.name = "LocalRain"
|
|
_rain.amount = RAIN_PARTICLE_AMOUNT
|
|
_rain.amount_ratio = 0.0
|
|
_rain.lifetime = 1.25
|
|
_rain.fixed_fps = 30
|
|
_rain.local_coords = false
|
|
_rain.visibility_aabb = AABB(
|
|
Vector3(-7.0, -9.0, -7.0), Vector3(14.0, 12.0, 14.0)
|
|
)
|
|
var process_material := ParticleProcessMaterial.new()
|
|
process_material.emission_shape = (
|
|
ParticleProcessMaterial.EMISSION_SHAPE_BOX
|
|
)
|
|
process_material.emission_box_extents = Vector3(6.5, 1.0, 6.5)
|
|
process_material.direction = Vector3.DOWN
|
|
process_material.spread = 5.0
|
|
process_material.initial_velocity_min = RAIN_VELOCITY_MIN
|
|
process_material.initial_velocity_max = RAIN_VELOCITY_MAX
|
|
process_material.gravity = Vector3(0.0, -2.0, 0.0)
|
|
_rain.process_material = process_material
|
|
var drop_mesh := BoxMesh.new()
|
|
drop_mesh.size = RAIN_DROP_SIZE
|
|
var drop_material := StandardMaterial3D.new()
|
|
drop_material.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
|
|
drop_material.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
|
|
drop_material.albedo_color = Color(0.48, 0.78, 0.90, 0.72)
|
|
drop_mesh.material = drop_material
|
|
_rain.draw_pass_1 = drop_mesh
|
|
add_child(_rain)
|
|
_update_rain_position()
|
|
|
|
|
|
func _prepare_storm_clouds() -> void:
|
|
_storm_clouds = LocalStormCloudLayerType.new()
|
|
_storm_clouds.name = "LocalStormClouds"
|
|
add_child(_storm_clouds)
|
|
_storm_clouds.setup(_rain_target)
|
|
|
|
|
|
func _apply_time(time_hours: float) -> void:
|
|
if _environment == null or _sky_material == null or _sun == null:
|
|
return
|
|
var hour: float = fposmod(time_hours, WorldTimeService.HOURS_PER_DAY)
|
|
var daylight: float = _daylight_amount(hour)
|
|
var warmth: float = _transition_warmth(hour)
|
|
var sky_top: Color = _blended_color(
|
|
NIGHT_SKY_TOP, DAY_SKY_TOP, WARM_SKY_TOP, daylight, warmth
|
|
)
|
|
var sky_horizon: Color = _blended_color(
|
|
NIGHT_SKY_HORIZON,
|
|
DAY_SKY_HORIZON,
|
|
WARM_SKY_HORIZON,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var ground_bottom: Color = _blended_color(
|
|
NIGHT_GROUND_BOTTOM,
|
|
DAY_GROUND_BOTTOM,
|
|
WARM_GROUND_BOTTOM,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var ground_horizon: Color = _blended_color(
|
|
NIGHT_GROUND_HORIZON,
|
|
DAY_GROUND_HORIZON,
|
|
WARM_GROUND_HORIZON,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var ambient: Color = _blended_color(
|
|
NIGHT_AMBIENT, DAY_AMBIENT, WARM_AMBIENT, daylight, warmth
|
|
)
|
|
var fog_color: Color = _blended_color(
|
|
NIGHT_FOG, DAY_FOG, WARM_FOG, daylight, warmth
|
|
)
|
|
var foggy_fog_amount: float = _weather_value(0.0, 0.0, 0.0, 1.0)
|
|
var rain_fog_amount: float = _weather_value(0.0, 0.0, 1.0, 0.0)
|
|
var fog_daylight_amount: float = daylight * foggy_fog_amount
|
|
var rain_daylight_amount: float = daylight * rain_fog_amount
|
|
var weather_fog_amount: float = minf(
|
|
rain_fog_amount + foggy_fog_amount,
|
|
1.0,
|
|
)
|
|
_environment.fog_enabled = weather_fog_amount > 0.001
|
|
var fog_scene_brightness: float = lerpf(
|
|
1.0,
|
|
FOG_DAYLIGHT_SCENE_BRIGHTNESS,
|
|
fog_daylight_amount,
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"sky_top_color", sky_top
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"sky_horizon_color",
|
|
sky_horizon,
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"ground_bottom_color",
|
|
ground_bottom,
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"ground_horizon_color",
|
|
ground_horizon,
|
|
)
|
|
_apply_sky_clouds(daylight, warmth)
|
|
_environment.background_energy_multiplier = (
|
|
lerpf(0.52, 0.85, daylight)
|
|
* _weather_value(1.0, 0.82, 0.66, 1.0)
|
|
* fog_scene_brightness
|
|
)
|
|
_environment.ambient_light_color = ambient
|
|
_environment.ambient_light_energy = (
|
|
lerpf(0.66, 1.08, daylight)
|
|
* _weather_value(1.0, 0.88, 0.76, 1.0)
|
|
* fog_scene_brightness
|
|
)
|
|
_environment.fog_light_color = fog_color
|
|
var fog_light_energy := (
|
|
lerpf(0.56, 0.82, daylight)
|
|
* _weather_value(1.0, 0.92, 0.82, 1.0)
|
|
* lerpf(
|
|
1.0,
|
|
FOG_DAYLIGHT_FOG_LIGHT_BRIGHTNESS,
|
|
fog_daylight_amount,
|
|
)
|
|
)
|
|
_environment.fog_light_energy = fog_light_energy
|
|
_environment.fog_aerial_perspective = _weather_value(
|
|
0.35, 0.48, 0.62, 0.0
|
|
)
|
|
_environment.fog_sky_affect = _weather_value(
|
|
0.35, 0.48, 0.68, 1.0
|
|
)
|
|
_environment.fog_depth_curve = _weather_value(
|
|
1.6, 1.5, 1.4, 1.18
|
|
)
|
|
_environment.fog_depth_begin = _weather_value(
|
|
42.0, 32.0, 20.0, 3.0
|
|
)
|
|
_environment.fog_depth_end = _weather_value(
|
|
170.0, 140.0, 95.0, 18.0
|
|
)
|
|
_apply_water_environment(
|
|
daylight,
|
|
warmth,
|
|
rain_fog_amount,
|
|
foggy_fog_amount,
|
|
_fog_render_color(fog_color, fog_light_energy),
|
|
)
|
|
_environment.adjustment_brightness = (
|
|
lerpf(0.93, 0.98, daylight)
|
|
* _weather_value(1.0, 0.97, 0.92, 1.0)
|
|
* lerpf(
|
|
1.0,
|
|
FOG_DAYLIGHT_POST_BRIGHTNESS,
|
|
fog_daylight_amount,
|
|
)
|
|
* lerpf(
|
|
1.0,
|
|
RAIN_DAYLIGHT_POST_BRIGHTNESS,
|
|
rain_daylight_amount,
|
|
)
|
|
)
|
|
_environment.adjustment_saturation = (
|
|
lerpf(0.82, 0.91, daylight)
|
|
* _weather_value(1.0, 0.88, 0.78, 1.0)
|
|
)
|
|
_sun.rotation_degrees = Vector3(
|
|
-360.0 * fposmod(hour - WorldTimeService.DAY_START_HOUR, 24.0) / 24.0,
|
|
SUN_YAW_DEGREES,
|
|
0.0,
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"sun_direction", _sun.global_transform.basis.z.normalized()
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"sun_color", DAY_SUN_DISC.lerp(WARM_SUN_DISC, warmth)
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"sun_visibility",
|
|
daylight * _weather_value(1.0, 0.65, 0.28, 1.0),
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"moon_direction", -_sun.global_transform.basis.z.normalized()
|
|
)
|
|
_sky_material.set_shader_parameter("moon_color", MOON_DISC)
|
|
_sky_material.set_shader_parameter(
|
|
"moon_visibility",
|
|
(1.0 - daylight) * _weather_value(1.0, 0.72, 0.36, 1.0),
|
|
)
|
|
_sun.light_color = _blended_color(
|
|
NIGHT_SUN, DAY_SUN, WARM_SUN, daylight, warmth
|
|
)
|
|
_sun.light_energy = (
|
|
lerpf(0.0, 0.10, daylight)
|
|
* _weather_value(1.0, 0.55, 0.25, 0.30)
|
|
)
|
|
_update_rain_amount()
|
|
|
|
|
|
func _apply_water_environment(
|
|
daylight: float,
|
|
warmth: float,
|
|
rain_fog_amount: float,
|
|
foggy_fog_amount: float,
|
|
fog_render_color: Color,
|
|
) -> void:
|
|
var water_tint := _blended_color(
|
|
NIGHT_WATER_TINT,
|
|
Color.WHITE,
|
|
WARM_WATER_TINT,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var water_brightness := (
|
|
lerpf(0.34, 1.0, daylight)
|
|
* _weather_value(1.0, 0.90, 0.78, 1.0)
|
|
* lerpf(
|
|
1.0,
|
|
FOG_DAYLIGHT_WATER_BRIGHTNESS,
|
|
daylight * _weather_value(0.0, 0.0, 0.0, 1.0),
|
|
)
|
|
)
|
|
var weather_fog_amount: float = minf(
|
|
rain_fog_amount + foggy_fog_amount,
|
|
1.0,
|
|
)
|
|
var foggy_color_weight: float = (
|
|
foggy_fog_amount / weather_fog_amount
|
|
if weather_fog_amount > 0.001
|
|
else 0.0
|
|
)
|
|
var water_fog_color := RAIN_WATER_FOG_COLOR.lerp(
|
|
fog_render_color,
|
|
foggy_color_weight,
|
|
)
|
|
for material: ShaderMaterial in [
|
|
SALT_WATER_MATERIAL,
|
|
FRESH_WATER_MATERIAL,
|
|
]:
|
|
material.set_shader_parameter("environment_tint", water_tint)
|
|
material.set_shader_parameter(
|
|
"environment_brightness",
|
|
water_brightness,
|
|
)
|
|
material.set_shader_parameter("weather_fog_color", water_fog_color)
|
|
material.set_shader_parameter(
|
|
"weather_fog_amount",
|
|
weather_fog_amount,
|
|
)
|
|
material.set_shader_parameter(
|
|
"weather_fog_begin",
|
|
_weather_value(42.0, 32.0, 20.0, 3.0),
|
|
)
|
|
material.set_shader_parameter(
|
|
"weather_fog_end",
|
|
_weather_value(170.0, 140.0, 95.0, 18.0),
|
|
)
|
|
material.set_shader_parameter(
|
|
"weather_fog_curve",
|
|
_weather_value(1.6, 1.5, 1.4, 1.18),
|
|
)
|
|
|
|
|
|
func _fog_render_color(fog_color: Color, fog_light_energy: float) -> Color:
|
|
var linear_fog_color := fog_color.srgb_to_linear()
|
|
linear_fog_color.r *= fog_light_energy
|
|
linear_fog_color.g *= fog_light_energy
|
|
linear_fog_color.b *= fog_light_energy
|
|
linear_fog_color.a = 1.0
|
|
return linear_fog_color.linear_to_srgb()
|
|
|
|
|
|
func _apply_sky_clouds(daylight: float, warmth: float) -> void:
|
|
var cloud_light := _blended_color(
|
|
NIGHT_CLOUD_LIGHT,
|
|
DAY_CLOUD_LIGHT,
|
|
WARM_CLOUD_LIGHT,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var cloud_shadow := _blended_color(
|
|
NIGHT_CLOUD_SHADOW,
|
|
DAY_CLOUD_SHADOW,
|
|
WARM_CLOUD_SHADOW,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
var storm_amount: float = _weather_value(0.0, 0.18, 0.55, 0.0)
|
|
cloud_light = cloud_light.lerp(cloud_shadow, storm_amount * 0.35)
|
|
cloud_shadow = cloud_shadow.lerp(
|
|
STORM_CLOUD_SHADOW,
|
|
storm_amount * 0.10,
|
|
)
|
|
var lower_cloud_color := _blended_color(
|
|
NIGHT_LOWER_CLOUD,
|
|
DAY_LOWER_CLOUD,
|
|
WARM_LOWER_CLOUD,
|
|
daylight,
|
|
warmth,
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"cloud_coverage",
|
|
_weather_value(0.0, 0.58, 0.985, 0.0),
|
|
)
|
|
_sky_material.set_shader_parameter(
|
|
"cloud_opacity",
|
|
_weather_value(0.0, 0.76, 1.0, 0.0),
|
|
)
|
|
_sky_material.set_shader_parameter("cloud_light_color", cloud_light)
|
|
_sky_material.set_shader_parameter("cloud_shadow_color", cloud_shadow)
|
|
if _storm_clouds != null:
|
|
_storm_clouds.set_storm_amount(
|
|
_weather_value(0.0, 0.0, 1.0, 0.0),
|
|
lower_cloud_color,
|
|
)
|
|
|
|
|
|
func _on_weather_changed(
|
|
weather: WorldWeatherService.Weather,
|
|
_seconds_remaining: float,
|
|
) -> void:
|
|
if weather == _weather_to:
|
|
return
|
|
_weather_from = _weather_to
|
|
_weather_to = weather
|
|
_weather_transition = 0.0
|
|
|
|
|
|
func _weather_value(
|
|
sunny: float,
|
|
cloudy: float,
|
|
rainy: float,
|
|
foggy: float,
|
|
) -> float:
|
|
return lerpf(
|
|
_weather_state_value(_weather_from, sunny, cloudy, rainy, foggy),
|
|
_weather_state_value(_weather_to, sunny, cloudy, rainy, foggy),
|
|
_weather_transition,
|
|
)
|
|
|
|
|
|
func _weather_state_value(
|
|
weather: WorldWeatherService.Weather,
|
|
sunny: float,
|
|
cloudy: float,
|
|
rainy: float,
|
|
foggy: float,
|
|
) -> float:
|
|
match weather:
|
|
WorldWeatherService.Weather.CLOUDY:
|
|
return cloudy
|
|
WorldWeatherService.Weather.RAINY:
|
|
return rainy
|
|
WorldWeatherService.Weather.FOGGY:
|
|
return foggy
|
|
return sunny
|
|
|
|
|
|
func _update_rain_amount() -> void:
|
|
if _rain == null:
|
|
return
|
|
var rain_amount: float = _weather_value(0.0, 0.0, 1.0, 0.0)
|
|
_rain.amount_ratio = rain_amount
|
|
_rain.emitting = rain_amount > 0.01
|
|
|
|
|
|
func _update_rain_position() -> void:
|
|
if _rain == null or _rain_target == null:
|
|
return
|
|
var anchor_position: Vector3 = _rain_target.global_position
|
|
if _rain_camera_provider.is_valid():
|
|
var camera_candidate: Variant = _rain_camera_provider.call()
|
|
if camera_candidate is Camera3D:
|
|
var active_camera := camera_candidate as Camera3D
|
|
if is_instance_valid(active_camera):
|
|
anchor_position = active_camera.global_position
|
|
_rain.global_position = anchor_position + RAIN_EMITTER_OFFSET
|
|
|
|
|
|
func _daylight_amount(hour: float) -> float:
|
|
if hour >= WorldTimeService.DAWN_START_HOUR and hour < WorldTimeService.DAWN_END_HOUR:
|
|
return smoothstep(
|
|
WorldTimeService.DAWN_START_HOUR,
|
|
WorldTimeService.DAWN_END_HOUR,
|
|
hour,
|
|
)
|
|
if hour >= WorldTimeService.DAWN_END_HOUR and hour < WorldTimeService.DUSK_START_HOUR:
|
|
return 1.0
|
|
if hour >= WorldTimeService.DUSK_START_HOUR and hour < WorldTimeService.DUSK_END_HOUR:
|
|
return 1.0 - smoothstep(
|
|
WorldTimeService.DUSK_START_HOUR,
|
|
WorldTimeService.DUSK_END_HOUR,
|
|
hour,
|
|
)
|
|
return 0.0
|
|
|
|
|
|
func _transition_warmth(hour: float) -> float:
|
|
if hour >= WorldTimeService.DAWN_START_HOUR and hour < WorldTimeService.DAWN_END_HOUR:
|
|
return 1.0 - absf(hour - WorldTimeService.DAY_START_HOUR) / WorldTimeService.TRANSITION_HALF_HOURS
|
|
if hour >= WorldTimeService.DUSK_START_HOUR and hour < WorldTimeService.DUSK_END_HOUR:
|
|
return 1.0 - absf(hour - WorldTimeService.NIGHT_START_HOUR) / WorldTimeService.TRANSITION_HALF_HOURS
|
|
return 0.0
|
|
|
|
|
|
func _blended_color(
|
|
night_color: Color,
|
|
day_color: Color,
|
|
warm_color: Color,
|
|
daylight: float,
|
|
warmth: float,
|
|
) -> Color:
|
|
return night_color.lerp(day_color, daylight).lerp(warm_color, warmth)
|