src/to_clt/sky.rs

   1 use super::*;
   2
   3 #[mt_derive(to = "clt", tag = "type", content = "data", custom)]
   4 pub enum Sky {
   5     Regular {
   6         day_sky: Color,
   7         day_horizon: Color,
   8         dawn_sky: Color,
   9         dawn_horizon: Color,
  10         night_sky: Color,
  11         night_horizon: Color,
  12         indoor: Color,
  13     },
  14     Skybox {
  15         textures: Vec<String>,
  16     },
  17     Plain,
  18 }
  19
  20 #[mt_derive(to = "clt", tag = "type", custom)]
  21 pub enum FogTint {
  22     Default,
  23     Custom { sun: Color, moon: Color },
  24 }
  25
  26 #[mt_derive(to = "clt", custom)]
  27 pub struct SkyParams {
  28     pub bg_color: Color,
  29     pub clouds: bool,
  30     pub fog_tint: FogTint,
  31     pub sky: Sky,
  32 }
  33
  34 #[cfg(feature = "server")]
  35 impl MtSerialize for SkyParams {
  36     fn mt_serialize<C: MtCfg>(
  37         &self,
  38         writer: &mut impl std::io::Write,
  39     ) -> Result<(), mt_ser::SerializeError> {
  40         self.bg_color.mt_serialize::<DefCfg>(writer)?;
  41
  42         match &self.sky {
  43             Sky::Regular { .. } => "regular",
  44             Sky::Skybox { .. } => "skybox",
  45             Sky::Plain => "plain",
  46         }
  47         .mt_serialize::<DefCfg>(writer)?;
  48
  49         self.clouds.mt_serialize::<DefCfg>(writer)?;
  50
  51         match &self.fog_tint {
  52             FogTint::Default => {
  53                 let unused_color = Color {
  54                     a: 0,
  55                     r: 0,
  56                     g: 0,
  57                     b: 0,
  58                 };
  59
  60                 unused_color.mt_serialize::<DefCfg>(writer)?;
  61                 unused_color.mt_serialize::<DefCfg>(writer)?;
  62                 "default".mt_serialize::<DefCfg>(writer)?;
  63             }
  64             FogTint::Custom { sun, moon } => {
  65                 sun.mt_serialize::<DefCfg>(writer)?;
  66                 moon.mt_serialize::<DefCfg>(writer)?;
  67                 "custom".mt_serialize::<DefCfg>(writer)?;
  68             }
  69         }
  70
  71         match &self.sky {
  72             Sky::Regular {
  73                 day_sky,
  74                 day_horizon,
  75                 dawn_sky,
  76                 dawn_horizon,
  77                 night_sky,
  78                 night_horizon,
  79                 indoor,
  80             } => {
  81                 day_sky.mt_serialize::<DefCfg>(writer)?;
  82                 day_horizon.mt_serialize::<DefCfg>(writer)?;
  83                 dawn_sky.mt_serialize::<DefCfg>(writer)?;
  84                 dawn_horizon.mt_serialize::<DefCfg>(writer)?;
  85                 night_sky.mt_serialize::<DefCfg>(writer)?;
  86                 night_horizon.mt_serialize::<DefCfg>(writer)?;
  87                 indoor.mt_serialize::<DefCfg>(writer)?;
  88             }
  89             Sky::Skybox { textures } => {
  90                 textures.mt_serialize::<DefCfg>(writer)?;
  91             }
  92             Sky::Plain => {}
  93         }
  94
  95         Ok(())
  96     }
  97 }
  98
  99 #[cfg(feature = "client")]
 100 impl MtDeserialize for SkyParams {
 101     fn mt_deserialize<C: MtCfg>(
 102         reader: &mut impl std::io::Read,
 103     ) -> Result<Self, mt_ser::DeserializeError> {
 104         use mt_ser::DeserializeError::InvalidEnum;
 105
 106         let bg_color = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 107         let sky_type = String::mt_deserialize::<DefCfg>(reader)?;
 108         let clouds = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 109
 110         let sun = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 111         let moon = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 112
 113         let fog_tint_type = String::mt_deserialize::<DefCfg>(reader)?;
 114         let fog_tint = match fog_tint_type.as_str() {
 115             "default" => FogTint::Default,
 116             "custom" => FogTint::Custom { sun, moon },
 117             _ => return Err(InvalidEnum("FogTint", Box::new(fog_tint_type))),
 118         };
 119
 120         let sky = match sky_type.as_str() {
 121             "regular" => {
 122                 let day_sky = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 123                 let day_horizon = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 124                 let dawn_sky = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 125                 let dawn_horizon = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 126                 let night_sky = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 127                 let night_horizon = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 128                 let indoor = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 129
 130                 Sky::Regular {
 131                     day_sky,
 132                     day_horizon,
 133                     dawn_sky,
 134                     dawn_horizon,
 135                     night_sky,
 136                     night_horizon,
 137                     indoor,
 138                 }
 139             }
 140             "skybox" => {
 141                 let textures = MtDeserialize::mt_deserialize::<DefCfg>(reader)?;
 142
 143                 Sky::Skybox { textures }
 144             }
 145             "plain" => Sky::Plain,
 146             _ => return Err(InvalidEnum("Sky", Box::new(sky_type))),
 147         };
 148
 149         Ok(Self {
 150             bg_color,
 151             clouds,
 152             fog_tint,
 153             sky,
 154         })
 155     }
 156 }
 157
 158 #[mt_derive(to = "clt")]
 159 pub struct SunParams {
 160     pub visible: bool,
 161     pub texture: String,
 162     pub tone_map: String,
 163     pub rise: String,
 164     pub rising: bool,
 165     pub size: f32,
 166 }
 167
 168 #[mt_derive(to = "clt")]
 169 pub struct MoonParams {
 170     pub visible: bool,
 171     pub texture: String,
 172     pub tone_map: String,
 173     pub size: f32,
 174 }
 175
 176 #[mt_derive(to = "clt")]
 177 pub struct StarParams {
 178     pub visible: bool,
 179     pub count: u32,
 180     pub color: Color,
 181     pub size: f32,
 182 }
 183
 184 #[mt_derive(to = "clt")]
 185 pub struct CloudParams {
 186     pub density: f32,
 187     pub diffuse_color: Color,
 188     pub ambient_color: Color,
 189     pub height: f32,
 190     pub thickness: f32,
 191     pub speed: Vector2<f32>,
 192 }