166 lines
5.4 KiB
Text
166 lines
5.4 KiB
Text
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);
|
|
uniform vec4 ground_horizon_color : source_color = vec4(0.549, 0.749, 0.765, 1.0);
|
|
uniform float horizon_blend_width : hint_range(0.005, 0.15, 0.005) = 0.01;
|
|
uniform vec4 fog_horizon_color : source_color = vec4(0.13, 0.21, 0.32, 1.0);
|
|
uniform float fog_horizon_occlusion : hint_range(0.0, 1.0) = 0.0;
|
|
|
|
uniform vec3 sun_direction = vec3(0.0, 1.0, 0.0);
|
|
uniform vec4 sun_color : source_color = vec4(1.0, 0.86, 0.46, 1.0);
|
|
uniform float sun_visibility : hint_range(0.0, 1.0) = 1.0;
|
|
uniform float sun_radius : hint_range(0.005, 0.15) = 0.055;
|
|
uniform float sun_edge_softness : hint_range(0.001, 0.03) = 0.003;
|
|
uniform float sun_halo_radius : hint_range(0.02, 0.35) = 0.14;
|
|
uniform float sun_halo_strength : hint_range(0.0, 1.0) = 0.16;
|
|
|
|
uniform vec3 moon_direction = vec3(0.0, -1.0, 0.0);
|
|
uniform vec4 moon_color : source_color = vec4(0.78, 0.88, 1.0, 1.0);
|
|
uniform float moon_visibility : hint_range(0.0, 1.0) = 0.0;
|
|
uniform float moon_radius : hint_range(0.005, 0.15) = 0.045;
|
|
uniform float moon_edge_softness : hint_range(0.001, 0.03) = 0.003;
|
|
uniform float moon_halo_radius : hint_range(0.02, 0.35) = 0.11;
|
|
uniform float moon_halo_strength : hint_range(0.0, 1.0) = 0.12;
|
|
|
|
uniform vec4 star_color : source_color = vec4(0.72, 0.82, 0.96, 1.0);
|
|
uniform float star_visibility : hint_range(0.0, 1.0) = 0.0;
|
|
uniform float star_strength : hint_range(0.0, 1.0) = 0.72;
|
|
|
|
|
|
float star_hash(vec2 point) {
|
|
vec3 value = fract(vec3(point.xyx) * vec3(0.1031, 0.1030, 0.0973));
|
|
value += dot(value, value.yzx + 33.33);
|
|
return fract((value.x + value.y) * value.z);
|
|
}
|
|
|
|
|
|
vec2 star_hash2(vec2 point) {
|
|
return vec2(
|
|
star_hash(point),
|
|
star_hash(point + vec2(19.19, 7.73))
|
|
);
|
|
}
|
|
|
|
|
|
float procedural_star_field(vec3 view_direction) {
|
|
// Map the upper hemisphere to one stable world-direction diamond. This
|
|
// avoids a longitude seam and keeps the stars fixed as the camera moves.
|
|
float direction_sum = max(
|
|
abs(view_direction.x)
|
|
+ abs(view_direction.y)
|
|
+ abs(view_direction.z),
|
|
0.0001
|
|
);
|
|
vec2 star_uv = view_direction.xz / direction_sum * 0.5 + 0.5;
|
|
vec2 star_point = star_uv * 190.0;
|
|
vec2 cell = floor(star_point);
|
|
vec2 local_point = fract(star_point);
|
|
float spawn_roll = star_hash(cell + vec2(3.17, 11.83));
|
|
vec2 point_center = mix(
|
|
vec2(0.18),
|
|
vec2(0.82),
|
|
star_hash2(cell + vec2(41.0, 73.0))
|
|
);
|
|
float point_radius = mix(
|
|
0.065,
|
|
0.13,
|
|
star_hash(cell + vec2(89.0, 17.0))
|
|
);
|
|
float point_shape = 1.0 - smoothstep(
|
|
point_radius,
|
|
point_radius + 0.045,
|
|
distance(local_point, point_center)
|
|
);
|
|
float point_exists = step(0.965, spawn_roll);
|
|
float point_brightness = mix(
|
|
0.42,
|
|
1.0,
|
|
smoothstep(0.965, 1.0, spawn_roll)
|
|
);
|
|
float upper_sky_fade = smoothstep(0.055, 0.22, view_direction.y);
|
|
return point_shape * point_exists * point_brightness * upper_sky_fade;
|
|
}
|
|
|
|
|
|
void sky() {
|
|
vec3 view_direction = normalize(EYEDIR);
|
|
float above_horizon = max(view_direction.y, 0.0);
|
|
float below_horizon = max(-view_direction.y, 0.0);
|
|
vec3 sky_color = mix(
|
|
sky_horizon_color.rgb,
|
|
sky_top_color.rgb,
|
|
pow(above_horizon, 0.72)
|
|
);
|
|
vec3 ground_color = mix(
|
|
ground_horizon_color.rgb,
|
|
ground_bottom_color.rgb,
|
|
pow(below_horizon, 0.16)
|
|
);
|
|
vec3 base_color = mix(
|
|
ground_color,
|
|
sky_color,
|
|
smoothstep(
|
|
-horizon_blend_width,
|
|
horizon_blend_width,
|
|
view_direction.y
|
|
)
|
|
);
|
|
float stars = procedural_star_field(view_direction);
|
|
base_color = mix(
|
|
base_color,
|
|
star_color.rgb,
|
|
stars * star_visibility * star_strength
|
|
);
|
|
|
|
float alignment = dot(view_direction, normalize(sun_direction));
|
|
float disc_outer = cos(sun_radius + sun_edge_softness);
|
|
float disc_inner = cos(sun_radius);
|
|
float halo_outer = cos(sun_halo_radius);
|
|
float sun_disc = smoothstep(disc_outer, disc_inner, alignment);
|
|
float sun_halo = smoothstep(halo_outer, disc_outer, alignment);
|
|
float horizon_visibility = smoothstep(-0.035, 0.02, sun_direction.y);
|
|
float visible_strength = sun_visibility * horizon_visibility;
|
|
base_color += sun_color.rgb * sun_halo * sun_halo_strength * visible_strength;
|
|
base_color = mix(base_color, sun_color.rgb, sun_disc * visible_strength);
|
|
|
|
float moon_alignment = dot(view_direction, normalize(moon_direction));
|
|
float moon_disc_outer = cos(moon_radius + moon_edge_softness);
|
|
float moon_disc_inner = cos(moon_radius);
|
|
float moon_halo_outer = cos(moon_halo_radius);
|
|
float moon_disc = smoothstep(
|
|
moon_disc_outer, moon_disc_inner, moon_alignment
|
|
);
|
|
float moon_halo = smoothstep(
|
|
moon_halo_outer, moon_disc_outer, moon_alignment
|
|
);
|
|
float moon_horizon_visibility = smoothstep(
|
|
-0.035, 0.02, moon_direction.y
|
|
);
|
|
float moon_visible_strength = (
|
|
moon_visibility * moon_horizon_visibility
|
|
);
|
|
base_color += (
|
|
moon_color.rgb
|
|
* moon_halo
|
|
* moon_halo_strength
|
|
* moon_visible_strength
|
|
);
|
|
base_color = mix(
|
|
base_color, moon_color.rgb, moon_disc * moon_visible_strength
|
|
);
|
|
base_color = apply_weather_clouds(base_color, view_direction);
|
|
// Compatibility fog does not fully erase the color split between a custom
|
|
// sky's upper and lower hemispheres. Dense low-light fog supplies one
|
|
// uniform sky color here so that split cannot masquerade as an ocean edge.
|
|
base_color = mix(
|
|
base_color,
|
|
fog_horizon_color.rgb,
|
|
fog_horizon_occlusion
|
|
);
|
|
|
|
COLOR = base_color;
|
|
}
|