Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove dead shader code, clean up weather.rs

Browse Source
This commit is contained in:
IsseW 2022-05-28 15:40:13 +02:00
parent dc8424c549
commit fd12c8abdb
5 changed files with 42 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
assets/voxygen/shaders/fluid-frag/shiny.glsl
View File

@ -58,7 +58,7 @@ vec3 warp_normal(vec3 norm, vec3 pos, float time) {
+ smooth_rand(pos * 0.25, time * 0.25) * 0.1);
}
float wave_height(vec3 pos, vec3 surf_norm) {
float wave_height(vec3 pos) {
float timer = tick.x * 0.75;
pos *= 0.5;
@ -134,9 +134,9 @@ void main() {
vec3 wave_pos = mod(f_pos + focus_off.xyz, vec3(100.0));
float wave_sample_dist = 0.025;
float wave00 = wave_height(wave_pos, surf_norm);
float wave10 = wave_height(wave_pos + vec3(wave_sample_dist, 0, 0), surf_norm);
float wave01 = wave_height(wave_pos + vec3(0, wave_sample_dist, 0), surf_norm);
float wave00 = wave_height(wave_pos);
float wave10 = wave_height(wave_pos + vec3(wave_sample_dist, 0, 0));
float wave01 = wave_height(wave_pos + vec3(0, wave_sample_dist, 0));
// Possibility of div by zero when slope = 0,
// however this only results in no water surface appearing

3
assets/voxygen/shaders/include/sky.glsl
View File

@ -113,11 +113,10 @@ layout(set = 0, binding = 12) uniform texture2D t_weather;
layout(set = 0, binding = 13) uniform sampler s_weather;
vec4 sample_weather(vec2 wpos) {
return textureLod(sampler2D(t_weather, s_weather), pos_to_uv(t_alt, s_alt, wpos - focus_off.xy), 0); // TODO: make this work for any world size
return textureLod(sampler2D(t_weather, s_weather), pos_to_uv(t_alt, s_alt, wpos - focus_off.xy), 0);
}
float cloud_tendency_at(vec2 pos) {
//float nz = textureLod(sampler2D(t_noise, s_noise), (pos + wind_offset) / 60000.0 / cloud_scale, 0).x - 0.3;
return sample_weather(pos).r;
}

10
client/src/lib.rs
View File

@ -162,6 +162,7 @@ impl WeatherLerp {
self.old = mem::replace(&mut self.new, (weather, Instant::now()));
}
// TODO: Make impårovements to this interpolation, it's main issue is assuming that updates come at regular intervals.
fn update(&mut self, to_update: &mut WeatherGrid) {
prof_span!("WeatherLerp::update");
let old = &self.old.0;
@ -173,7 +174,7 @@ impl WeatherLerp {
*to_update = new.clone();
}
if old.size() == new.size() {
// Assume updates are regular
// Assumes updates are regular
let t = (self.new.1.elapsed().as_secs_f32()
/ self.new.1.duration_since(self.old.1).as_secs_f32())
.clamp(0.0, 1.0);
@ -182,7 +183,7 @@ impl WeatherLerp {
.iter_mut()
.zip(old.iter().zip(new.iter()))
.for_each(|((_, current), ((_, old), (_, new)))| {
*current = Weather::lerp(old, new, t);
*current = Weather::lerp_unclamped(old, new, t);
});
}
}
@ -191,8 +192,8 @@ impl WeatherLerp {
impl Default for WeatherLerp {
fn default() -> Self {
Self {
old: (WeatherGrid::new(Vec2::broadcast(0)), Instant::now()),
new: (WeatherGrid::new(Vec2::broadcast(0)), Instant::now()),
old: (WeatherGrid::new(Vec2::zero()), Instant::now()),
new: (WeatherGrid::new(Vec2::zero()), Instant::now()),
}
}
}
@ -1461,6 +1462,7 @@ impl Client {
.map(|v| v.0)
}
/// Returns Weather::default if no player position exists.
pub fn weather_at_player(&self) -> Weather {
self.position()
.map(|wpos| self.state.weather_at(wpos.xy()))

52
common/src/weather.rs
View File

@ -20,24 +20,23 @@ impl Weather {
pub fn new(cloud: f32, rain: f32, wind: Vec2<f32>) -> Self { Self { cloud, rain, wind } }
pub fn get_kind(&self) -> WeatherKind {
match (
(self.cloud * 10.0) as i32,
(self.rain * 10.0) as i32,
(self.wind.magnitude() * 10.0) as i32,
) {
// Over 24.5 m/s wind is a storm
(_, _, 245..) => WeatherKind::Storm,
(_, 1..=10, _) => WeatherKind::Rain,
(4..=10, _, _) => WeatherKind::Cloudy,
_ => WeatherKind::Clear,
// Over 24.5 m/s wind is a storm
if self.wind.magnitude_squared() >= 24.5f32.powi(2) {
WeatherKind::Storm
} else if (0.1..=1.0).contains(&self.rain) {
WeatherKind::Rain
} else if (0.2..=1.0).contains(&self.cloud) {
WeatherKind::Cloudy
} else {
WeatherKind::Clear
}
}
pub fn lerp(from: &Self, to: &Self, t: f32) -> Self {
pub fn lerp_unclamped(from: &Self, to: &Self, t: f32) -> Self {
Self {
cloud: f32::lerp(from.cloud, to.cloud, t),
rain: f32::lerp(from.rain, to.rain, t),
wind: Vec2::<f32>::lerp(from.wind, to.wind, t),
cloud: f32::lerp_unclamped(from.cloud, to.cloud, t),
rain: f32::lerp_unclamped(from.rain, to.rain, t),
wind: Vec2::<f32>::lerp_unclamped(from.wind, to.wind, t),
}
}
@ -68,18 +67,18 @@ impl fmt::Display for WeatherKind {
}
}
// How many chunks wide a weather cell is.
// So one weather cell has (CHUNKS_PER_CELL * CHUNKS_PER_CELL) chunks.
pub const CHUNKS_PER_CELL: u32 = 16;
pub const CELL_SIZE: u32 = CHUNKS_PER_CELL * TerrainChunkSize::RECT_SIZE.x;
/// How often the weather is updated, in seconds
pub const WEATHER_DT: f32 = 5.0;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WeatherGrid {
weather: Grid<Weather>,
}
/// Returns the center of the weather cell at the given position
fn to_cell_pos(wpos: Vec2<f32>) -> Vec2<f32> { wpos / CELL_SIZE as f32 - 0.5 }
// TODO: Move consts from world to common to avoid duplication
@ -97,6 +96,7 @@ const LOCALITY: [Vec2<i32>; 9] = [
impl WeatherGrid {
pub fn new(size: Vec2<u32>) -> Self {
size.map(|e| debug_assert!(i32::try_from(e).is_ok()));
Self {
weather: Grid::new(size.as_(), Weather::default()),
}
@ -114,24 +114,24 @@ impl WeatherGrid {
/// interpolation between four cells.
pub fn get_interpolated(&self, wpos: Vec2<f32>) -> Weather {
let cell_pos = to_cell_pos(wpos);
let rpos = cell_pos.map(|e| e.fract());
let rpos = cell_pos.map(|e| e.fract() + (1.0 - e.signum()) / 2.0);
let cell_pos = cell_pos.map(|e| e.floor());
let wpos = cell_pos.as_::<i32>();
Weather::lerp(
&Weather::lerp(
self.weather.get(wpos).unwrap_or(&Weather::default()),
let cpos = cell_pos.as_::<i32>();
Weather::lerp_unclamped(
&Weather::lerp_unclamped(
self.weather.get(cpos).unwrap_or(&Weather::default()),
self.weather
.get(wpos + Vec2::unit_x())
.get(cpos + Vec2::unit_x())
.unwrap_or(&Weather::default()),
rpos.x,
),
&Weather::lerp(
&Weather::lerp_unclamped(
self.weather
.get(wpos + Vec2::unit_x())
.get(cpos + Vec2::unit_y())
.unwrap_or(&Weather::default()),
self.weather
.get(wpos + Vec2::one())
.get(cpos + Vec2::one())
.unwrap_or(&Weather::default()),
rpos.x,
),

9
server/src/weather/mod.rs
View File

@ -1,4 +1,4 @@
use common::weather::{CHUNKS_PER_CELL, WEATHER_DT};
use common::weather::CHUNKS_PER_CELL;
use common_ecs::{dispatch, System};
use common_state::State;
use specs::DispatcherBuilder;
@ -16,12 +16,13 @@ pub fn add_server_systems(dispatch_builder: &mut DispatcherBuilder) {
}
pub fn init(state: &mut State, world: &world::World) {
// How many chunks wide a weather cell is.
// 16 here means that a weather cell is 16x16 chunks.
let weather_size = world.sim().get_size() / CHUNKS_PER_CELL;
let sim = sim::WeatherSim::new(weather_size, world);
state.ecs_mut().insert(sim);
// Tick weather every 2 seconds
/// How often the weather is updated, in seconds
pub const WEATHER_DT: f32 = 5.0;
state
.ecs_mut()
.insert(SysScheduler::<tick::Sys>::every(Duration::from_secs_f32(