rust/mapgen/src/theme.rs
changeset 14164 1749961647b9
parent 14160 c24a76f131d6
child 14170 a4c1a2d0ac24
equal deleted inserted replaced
14163:e337e9920440 14164:1749961647b9
     1 use std::{
     1 use std::{
     2     slice::from_raw_parts_mut,
     2     slice::{
       
     3         from_raw_parts,
       
     4         from_raw_parts_mut
       
     5     },
     3     io,
     6     io,
     4     io::BufReader,
     7     io::BufReader,
     5     fs::{File, read_dir},
     8     fs::{File, read_dir},
     6     path::Path
     9     path::Path
     7 };
    10 };
    53     pub fn land_texture(&self) -> Option<&ThemeSprite> {
    56     pub fn land_texture(&self) -> Option<&ThemeSprite> {
    54         self.land_texture.as_ref()
    57         self.land_texture.as_ref()
    55     }
    58     }
    56 }
    59 }
    57 
    60 
       
    61 #[derive(Debug)]
    58 pub enum ThemeLoadError {
    62 pub enum ThemeLoadError {
    59     File(io::Error),
    63     File(io::Error),
    60     Decoding(DecodingError),
    64     Decoding(DecodingError),
    61     Format(String)
    65     Format(String)
    62 }
    66 }
    84         let mut theme = Self::new();
    88         let mut theme = Self::new();
    85 
    89 
    86         for entry in read_dir(path)? {
    90         for entry in read_dir(path)? {
    87             let file = entry?;
    91             let file = entry?;
    88             if file.file_name() == "LandTex.png" {
    92             if file.file_name() == "LandTex.png" {
    89                 let buffer = BufReader::new(File::create(file.path())?);
    93                 let decoder = Decoder::new(
    90                 let decoder = Decoder::new(buffer);
    94                     BufReader::new(File::open(file.path())?));
    91                 let (info, mut reader) = decoder.read_info()?;
    95                 let (info, mut reader) = decoder.read_info()?;
    92 
    96 
    93                 if info.color_type != ColorType::RGBA {
    97                 if info.color_type != ColorType::RGBA {
    94                     return Err(ThemeLoadError::Format(
    98                     return Err(ThemeLoadError::Format(
    95                         format!("Unexpected format: {:?}", info.color_type)));
    99                         format!("Unexpected format: {:?}", info.color_type)));
    96                 }
   100                 }
    97                 let size = Size::new(info.width as usize, info.height as usize);
   101                 let size = Size::new(info.width as usize, info.height as usize);
    98 
   102 
    99                 let mut buffer: Vec2D<u32> = Vec2D::new(size, 0);
   103                 let mut buffer: Vec2D<u32> = Vec2D::new(size, 0);
   100                 let slice_u32 = buffer.as_mut_slice();
   104                 reader.next_frame(slice_u32_to_u8_mut(buffer.as_mut_slice()))?;
   101                 let slice_u8 = unsafe {
       
   102                     from_raw_parts_mut::<u8>(
       
   103                         slice_u32.as_mut_ptr() as *mut u8,
       
   104                         slice_u32.len() / 4
       
   105                     )
       
   106                 };
       
   107                 reader.next_frame(slice_u8)?;
       
   108 
   105 
   109                 let land_tex = ThemeSprite {
   106                 let land_tex = ThemeSprite {
   110                     pixels: buffer
   107                     pixels: buffer
   111                 };
   108                 };
   112                 theme.land_texture = Some(land_tex)
   109                 theme.land_texture = Some(land_tex)
   115 
   112 
   116         Ok(theme)
   113         Ok(theme)
   117     }
   114     }
   118 }
   115 }
   119 
   116 
       
   117 pub fn slice_u32_to_u8(slice_u32: &[u32]) -> &[u8] {
       
   118     unsafe {
       
   119         from_raw_parts::<u8>(
       
   120             slice_u32.as_ptr() as *const u8,
       
   121             slice_u32.len() * 4
       
   122         )
       
   123     }
       
   124 }
   120 
   125 
       
   126 pub fn slice_u32_to_u8_mut(slice_u32: &mut [u32]) -> &mut [u8] {
       
   127     unsafe {
       
   128         from_raw_parts_mut::<u8>(
       
   129             slice_u32.as_mut_ptr() as *mut u8,
       
   130             slice_u32.len() * 4
       
   131         )
       
   132     }
       
   133 }
       
   134