Fichiers
moteur-terrain/carte-monde/src/lib.rs
T

166 lignes
6.9 KiB
Rust

//! Carte du monde : 4 champs de bruit tres basse frequence -> biome de relief -> poids lisses.
//!
//! Les types `BiomeRelief` sont definis localement (module `types`) en attendant `rt-core::proc` [A VERIFIER].
//! Tout est deterministe (graine u64, hachage entier). `CarteMonde` est `Send + Sync`, sans verrou.
mod bruit;
pub mod png;
pub mod types;
pub use types::{adjacence, Adjacence, BiomeRelief, Climat, TOUS};
use bruit::{fbm, ridged};
/// Ecart-type du lissage des frontieres (m).
pub const SIGMA_M: f64 = 400.0;
/// Bande de piemont minimale entre glaciaire et le reste (m) : verifiee par test.
pub const PIEMONT_MIN_M: f64 = 3000.0;
const T_PLAINE: f32 = 0.10;
const T_BOCAGE: f32 = 0.24;
const T_BOCAGE_HUMIDE: f32 = 0.30;
const T_KARST: f32 = 0.48;
const T_GLACIAIRE: f32 = 0.79;
#[derive(Clone, Debug)]
pub struct CarteMonde {
seed: u64,
forcer: Option<BiomeRelief>,
}
impl CarteMonde {
pub fn new(seed: u64) -> Self { Self { seed, forcer: None } }
/// Force un biome unique partout (tests de relief isole).
pub fn forcer(mut self, b: BiomeRelief) -> Self { self.forcer = Some(b); self }
pub fn seed(&self) -> u64 { self.seed }
/// Latitude fictive 35..70 deg : onde triangle lissee le long de z (periode 600 km).
pub fn lat_deg(z: f64) -> f32 {
let t = (z / 300_000.0).rem_euclid(2.0);
let tri = if t < 1.0 { t } else { 2.0 - t };
let s = tri * tri * (3.0 - 2.0 * tri);
35.0 + 35.0 * s as f32
}
/// Les 4 champs plus la latitude. `temperature` : au niveau de la mer (C).
pub fn climat(&self, x: f64, z: f64) -> Climat {
let s = self.seed;
let continentalite = ((fbm(s ^ 0x11, x / 40_000.0, z / 40_000.0, 1) * 2.0 - 1.0) as f32 * 1.1).clamp(-1.0, 1.0);
let soulevement = ridged(s ^ 0x22, x / 30_000.0, z / 30_000.0, 2) as f32;
let lat_deg = Self::lat_deg(z);
let t_bruit = (fbm(s ^ 0x33, x / 40_000.0, z / 40_000.0, 2) * 2.0 - 1.0) as f32 * 4.0;
let temperature = physique::temp_niveau_mer_lat(lat_deg) + t_bruit;
// foehn : sec sous le vent (vent d'ouest, x croissant) des chaines situees 15 km au vent
let souv_vent = ridged(s ^ 0x22, (x - 15_000.0) / 30_000.0, z / 30_000.0, 2) as f32;
let h0 = fbm(s ^ 0x44, x / 25_000.0, z / 25_000.0, 3) as f32;
let humidite = (h0 * 1.4 - 0.2 - 0.45 * (souv_vent - 0.4).max(0.0)).clamp(0.0, 1.0);
Climat { temperature, humidite, continentalite, soulevement, lat_deg }
}
/// Temperature moyenne annuelle corrigee de l'altitude (C), via `physique`.
pub fn temperature_a(&self, x: f64, z: f64, alt_m: f32) -> f32 {
physique::temp_a_altitude(self.climat(x, z).temperature, 0.0, alt_m)
}
/// Indice de relief 0..1 apres attenuation cotiere (le fjord garde son relief jusqu'a la mer).
fn niveau_et_fjord(&self, c: &Climat) -> (f32, bool) {
let froid = smooth(6.0, 2.0, c.temperature);
let f = smooth(0.50, 0.60, c.soulevement) * froid;
let fjord = f >= 0.9 && c.soulevement >= 0.62;
let ramp = ((c.continentalite - 0.25) / 0.75).clamp(0.0, 1.0); // lineaire : pente minimale
let g = ramp.max(smooth(0.6, 0.9, f)); // continu : pas de saut a l'entree du regime fjord
(c.soulevement * g, fjord)
}
/// Biome discret (sans lissage) en un point.
pub fn biome(&self, x: f64, z: f64) -> BiomeRelief {
if let Some(b) = self.forcer { return b; }
self.biome_climat(x, z, &self.climat(x, z))
}
fn biome_climat(&self, x: f64, z: f64, c: &Climat) -> BiomeRelief {
use BiomeRelief::*;
if c.continentalite < 0.0 { return Mer; }
let (n, fjord) = self.niveau_et_fjord(c);
if c.continentalite < 0.25 {
return if fjord { Fjord } else { CoteRocheuse };
}
let t_boc = T_BOCAGE + (T_BOCAGE_HUMIDE - T_BOCAGE) * smooth(0.40, 0.60, c.humidite); // continu en humidite
if n < T_PLAINE {
Plaine
} else if n < t_boc {
Bocage
} else if n < T_KARST {
let g = fbm(self.seed ^ 0x55, x / 6_000.0, z / 6_000.0, 2);
if n > 0.36 && g > 0.62 { Gorges } else { Karst }
} else if n < T_GLACIAIRE {
Prealpes
} else {
Glaciaire
}
}
/// Poids de biomes lisses (gaussienne sigma = 400 m), accentues (exposant 3), 3 biomes max, somme = 1.
/// Les emplacements inutilises ont un poids 0.
pub fn poids_biomes(&self, x: f64, z: f64) -> [(BiomeRelief, f32); 3] {
if let Some(b) = self.forcer { return [(b, 1.0), (b, 0.0), (b, 0.0)]; }
const N: i32 = 5; // pochoir (2N+1)^2, pas 120 m (+-600 m = 1,5 sigma)
const PAS: f64 = 120.0;
let mut acc = [0.0f32; 9];
let mut tot = 0.0f32;
for j in -N..=N {
for i in -N..=N {
let (dx, dz) = (i as f64 * PAS, j as f64 * PAS);
let w = (-(dx * dx + dz * dz) / (2.0 * SIGMA_M * SIGMA_M)).exp() as f32;
acc[self.biome(x + dx, z + dz) as usize] += w;
tot += w;
}
}
let mut v = [(BiomeRelief::Mer, 0.0f32); 9];
for (k, &b) in TOUS.iter().enumerate() { v[k] = (b, (acc[b as usize] / tot).powi(3)); }
v.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap().then((a.0 as u8).cmp(&(b.0 as u8))));
let s = v[0].1 + v[1].1 + v[2].1;
[(v[0].0, v[0].1 / s), (v[1].0, v[1].1 / s), (v[2].0, v[2].1 / s)]
}
/// Couleur RGB d'un point : melange des couleurs de biome selon les poids.
pub fn couleur(&self, x: f64, z: f64) -> [u8; 3] {
let mut c = [0.0f32; 3];
for (b, w) in self.poids_biomes(x, z) {
let k = b.couleur();
for i in 0..3 { c[i] += k[i] as f32 * w; }
}
[c[0] as u8, c[1] as u8, c[2] as u8]
}
/// Rendu PNG : `km` x `km` depuis (x0, z0) en metres, 1 px = `pas_m` metres, couleurs melangees par les poids.
pub fn rendu_carte(&self, x0: i64, z0: i64, km: u32, pas_m: u32) -> Vec<u8> {
let n = (km as u64 * 1000 / pas_m as u64) as usize;
let mut rgb = vec![0u8; n * n * 3];
let band = (n + 3) / 4;
std::thread::scope(|sc| {
for (t, chunk) in rgb.chunks_mut(band * n * 3).enumerate() {
sc.spawn(move || {
for (r, row) in chunk.chunks_mut(n * 3).enumerate() {
let z = z0 as f64 + ((t * band + r) as f64 + 0.5) * pas_m as f64;
for px in 0..n {
let x = x0 as f64 + (px as f64 + 0.5) * pas_m as f64;
row[px * 3..px * 3 + 3].copy_from_slice(&self.couleur(x, z));
}
}
});
}
});
png::encoder(n, n, &rgb)
}
}
/// Smoothstep entre a et b (b < a autorise : decroissant).
fn smooth(a: f32, b: f32, x: f32) -> f32 {
let t = ((x - a) / (b - a)).clamp(0.0, 1.0);
t * t * (3.0 - 2.0 * t)
}
#[cfg(test)]
mod tests;