mercurys 0.0.3

Mercury celestial simulation crate for the MilkyWay SolarSystem workspace
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SurfaceType {
    IntercraterPlains,
    SmoothPlains,
    CrateredHighlands,
    CraterFloor,
    CraterRim,
    LobateScarp,
    Hollows,
    PolarIce,
}

impl SurfaceType {
    pub fn base_albedo(&self) -> f32 {
        match self {
            Self::IntercraterPlains => 0.10,
            Self::SmoothPlains => 0.12,
            Self::CrateredHighlands => 0.09,
            Self::CraterFloor => 0.11,
            Self::CraterRim => 0.08,
            Self::LobateScarp => 0.10,
            Self::Hollows => 0.25,
            Self::PolarIce => 0.80,
        }
    }

    pub fn roughness(&self) -> f32 {
        match self {
            Self::IntercraterPlains => 0.7,
            Self::SmoothPlains => 0.5,
            Self::CrateredHighlands => 0.9,
            Self::CraterFloor => 0.6,
            Self::CraterRim => 0.85,
            Self::LobateScarp => 0.75,
            Self::Hollows => 0.4,
            Self::PolarIce => 0.3,
        }
    }
}

pub struct SplatWeights {
    pub intercrater: f32,
    pub smooth: f32,
    pub highlands: f32,
    pub ice: f32,
}

impl SplatWeights {
    pub fn normalize(&mut self) {
        let total = self.intercrater + self.smooth + self.highlands + self.ice;
        if total > 0.0 {
            self.intercrater /= total;
            self.smooth /= total;
            self.highlands /= total;
            self.ice /= total;
        }
    }
}

pub fn classify_surface(lat: f64, lon: f64, elevation_m: f64) -> SurfaceType {
    if !(lat.is_finite() && lon.is_finite() && elevation_m.is_finite()) {
        return SurfaceType::IntercraterPlains;
    }

    if lat.abs() > 85.0 && elevation_m < -1000.0 {
        return SurfaceType::PolarIce;
    }
    if elevation_m > 1500.0 {
        return SurfaceType::CraterRim;
    }
    if elevation_m < -2000.0 {
        return SurfaceType::CraterFloor;
    }
    if lat.abs() > 60.0 {
        return SurfaceType::SmoothPlains;
    }
    if lat.abs() < 30.0 {
        SurfaceType::IntercraterPlains
    } else {
        SurfaceType::CrateredHighlands
    }
}

pub fn biome(lat: f64, lon: f64) -> &'static str {
    if !(lat.is_finite() && lon.is_finite()) {
        return "unknown";
    }

    if lat.abs() < 10.0 {
        "equatorial"
    } else if lat.abs() < 60.0 {
        "mid-latitude"
    } else {
        "polar"
    }
}