Fichiers
moteur-terrain/proc-relief/src/erosion.rs
T

154 lignes
5.6 KiB
Rust
Brut Annotations Historique

Ce fichier contient des caractères Unicode ambigus.
Ce fichier contient des caractères Unicode qui peuvent être confondus avec d'autres caractères. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
//! Érosion hydraulique (gouttelettes, d'après S. Lague) et thermique (talus),
//! sur une grille carrée `n × n` de pas `pas` m. Entièrement déterministe :
//! les gouttelettes sont traitées dans l'ordre, chacune avec sa graine `hash(seed, i)`.
use crate::bruit::{hash2, unif};
use crate::relief::ParamsErosion;
const INERTIE: f32 = 0.05;
const PENTE_MIN: f32 = 0.01;
const VITESSE_EROSION: f32 = 0.3;
const GRAVITE: f32 = 4.0;
const PAS_MAX: usize = 64;
/// Limites anti-ravines sur pentes très raides (fjord, glaciaire) [À VÉRIFIER].
const EROSION_MAX_PAS: f32 = 0.5;
const VITESSE_MAX: f32 = 6.0;
#[inline]
fn hauteur_grad(h: &[f32], n: usize, px: f32, pz: f32) -> (f32, f32, f32) {
let (ix, iz) = (px as usize, pz as usize);
let (fx, fz) = (px - ix as f32, pz - iz as f32);
let i = iz * n + ix;
let (a, b, c, d) = (h[i], h[i + 1], h[i + n], h[i + n + 1]);
let gx = (b - a) * (1.0 - fz) + (d - c) * fz;
let gz = (c - a) * (1.0 - fx) + (d - b) * fx;
let hh = a * (1.0 - fx) * (1.0 - fz) + b * fx * (1.0 - fz) + c * (1.0 - fx) * fz + d * fx * fz;
(hh, gx, gz)
}
#[inline]
fn deposer(h: &mut [f32], n: usize, px: f32, pz: f32, q: f32) {
let (ix, iz) = (px as usize, pz as usize);
let (fx, fz) = (px - ix as f32, pz - iz as f32);
let i = iz * n + ix;
h[i] += q * (1.0 - fx) * (1.0 - fz);
h[i + 1] += q * fx * (1.0 - fz);
h[i + n] += q * (1.0 - fx) * fz;
h[i + n + 1] += q * fx * fz;
}
/// `h` en mètres ; les pentes sont exprimées en m par maille.
pub fn hydraulique(h: &mut [f32], n: usize, e: &ParamsErosion, seed: u64) {
let lim = (n - 1) as f32;
for g in 0..e.iterations_hydro {
let r = hash2(seed, g as i64, 0x51);
let mut px = unif(r) * (lim - 1.0);
let mut pz = unif(r.rotate_left(29)) * (lim - 1.0);
let (mut dx, mut dz) = (0.0f32, 0.0f32);
let (mut v, mut eau, mut sed) = (1.0f32, e.pluie, 0.0f32);
for _ in 0..PAS_MAX {
let (h0, gx, gz) = hauteur_grad(h, n, px, pz);
dx = dx * INERTIE - gx * (1.0 - INERTIE);
dz = dz * INERTIE - gz * (1.0 - INERTIE);
let l = (dx * dx + dz * dz).sqrt();
if l < 1e-6 {
break;
}
dx /= l;
dz /= l;
let (nx, nz) = (px + dx, pz + dz);
if nx < 0.0 || nz < 0.0 || nx >= lim || nz >= lim {
break;
}
let (h1, _, _) = hauteur_grad(h, n, nx, nz);
let dh = h1 - h0;
let cap = (-dh).max(PENTE_MIN) * v * eau * e.capacite;
if sed > cap || dh > 0.0 {
let q = if dh > 0.0 { dh.min(sed) } else { (sed - cap) * e.depot };
sed -= q;
deposer(h, n, px, pz, q);
} else {
let q = ((cap - sed) * VITESSE_EROSION).min(-dh).min(EROSION_MAX_PAS);
sed += q;
deposer(h, n, px, pz, -q);
}
v = (v * v - dh * GRAVITE).max(0.0).sqrt().min(VITESSE_MAX);
eau *= 1.0 - e.evaporation;
px = nx;
pz = nz;
}
}
}
/// Glissement thermique (Jacobi, donc indépendant de l'ordre de parcours).
pub fn thermique(h: &mut [f32], n: usize, pas: f32, iterations: u32, angle_deg: f32) {
let talus = angle_deg.to_radians().tan() * pas;
let mut d = vec![0.0f32; n * n];
for _ in 0..iterations {
d.iter_mut().for_each(|v| *v = 0.0);
for z in 1..n - 1 {
for x in 1..n - 1 {
let i = z * n + x;
let h0 = h[i];
let vois = [i - 1, i + 1, i - n, i + n];
let (mut tot, mut maxd) = (0.0f32, 0.0f32);
for &j in &vois {
let df = h0 - h[j] - talus;
if df > 0.0 {
tot += df;
maxd = maxd.max(df);
}
}
if tot > 0.0 {
let mv = 0.25 * maxd;
for &j in &vois {
let df = h0 - h[j] - talus;
if df > 0.0 {
let s = mv * df / tot;
d[i] -= s;
d[j] += s;
}
}
}
}
}
for (a, b) in h.iter_mut().zip(&d) {
*a += *b;
}
}
}
/// Accumulation de flux D8 (en nombre de mailles drainées, y compris la maille).
pub fn accumulation_d8(h: &[f32], n: usize) -> Vec<f32> {
let mut ordre: Vec<u32> = (0..(n * n) as u32).collect();
ordre.sort_unstable_by(|&a, &b| h[b as usize].total_cmp(&h[a as usize]).then(a.cmp(&b)));
let mut acc = vec![1.0f32; n * n];
const D: [(i32, i32, f32); 8] = [
(1, 0, 1.0), (-1, 0, 1.0), (0, 1, 1.0), (0, -1, 1.0),
(1, 1, std::f32::consts::SQRT_2), (-1, 1, std::f32::consts::SQRT_2),
(1, -1, std::f32::consts::SQRT_2), (-1, -1, std::f32::consts::SQRT_2),
];
for &c in &ordre {
let c = c as usize;
let (x, z) = ((c % n) as i32, (c / n) as i32);
let mut best = None;
let mut bp = 0.0f32;
for &(dx, dz, l) in &D {
let (xx, zz) = (x + dx, z + dz);
if xx < 0 || zz < 0 || xx >= n as i32 || zz >= n as i32 {
continue;
}
let j = zz as usize * n + xx as usize;
let p = (h[c] - h[j]) / l;
if p > bp {
bp = p;
best = Some(j);
}
}
if let Some(j) = best {
acc[j] += acc[c];
}
}
acc
}