rust/lib-hedgewars-engine/src/world.rs
changeset 15190 e2adb40c7988
parent 14718 5915a199cb81
child 15263 24828281c9c5
equal deleted inserted replaced
15189:ff397798e812 15190:e2adb40c7988
     6     outline_template::OutlineTemplate, template_based::TemplatedLandGenerator,
     6     outline_template::OutlineTemplate, template_based::TemplatedLandGenerator,
     7     LandGenerationParameters, LandGenerator,
     7     LandGenerationParameters, LandGenerator,
     8 };
     8 };
     9 use lfprng::LaggedFibonacciPRNG;
     9 use lfprng::LaggedFibonacciPRNG;
    10 
    10 
    11 use crate::render::{camera::Camera, MapRenderer};
    11 use crate::render::{camera::Camera, GearRenderer, MapRenderer};
    12 
    12 
    13 struct GameState {
    13 struct GameState {
    14     land: Land2D<u32>,
    14     land: Land2D<u32>,
    15     physics: hwp::World,
    15     physics: hwp::World,
    16 }
    16 }
    23 
    23 
    24 pub struct World {
    24 pub struct World {
    25     random_numbers_gen: LaggedFibonacciPRNG,
    25     random_numbers_gen: LaggedFibonacciPRNG,
    26     preview: Option<Land2D<u8>>,
    26     preview: Option<Land2D<u8>>,
    27     game_state: Option<GameState>,
    27     game_state: Option<GameState>,
    28     renderer: Option<MapRenderer>,
    28     map_renderer: Option<MapRenderer>,
       
    29     gear_renderer: Option<GearRenderer>,
    29     camera: Camera,
    30     camera: Camera,
    30     last_gear_id: GearId,
    31     last_gear_id: GearId,
    31 }
    32 }
    32 
    33 
    33 impl World {
    34 impl World {
    34     pub fn new() -> Self {
    35     pub fn new() -> Self {
    35         Self {
    36         Self {
    36             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    37             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    37             preview: None,
    38             preview: None,
    38             game_state: None,
    39             game_state: None,
    39             renderer: None,
    40             map_renderer: None,
       
    41             gear_renderer: None,
    40             camera: Camera::new(),
    42             camera: Camera::new(),
    41             last_gear_id: GearId::default(),
    43             last_gear_id: GearId::default(),
    42         }
    44         }
    43     }
    45     }
    44 
    46 
    45     pub fn create_renderer(&mut self, width: u16, height: u16) {
    47     pub fn create_renderer(&mut self, width: u16, height: u16) {
    46         let land_tile_size = Size::square(512);
    48         let land_tile_size = Size::square(512);
    47         self.renderer = Some(MapRenderer::new(land_tile_size));
    49         self.map_renderer = Some(MapRenderer::new(land_tile_size));
       
    50         self.gear_renderer = Some(GearRenderer::new());
    48         self.camera = Camera::with_size(Size::new(width as usize, height as usize));
    51         self.camera = Camera::with_size(Size::new(width as usize, height as usize));
    49 
    52 
    50         use mapgen::{theme::Theme, MapGenerator};
    53         use mapgen::{theme::Theme, MapGenerator};
    51         use std::path::Path;
    54         use std::path::Path;
    52 
    55 
    54             self.camera.position = state.land.play_box().center();
    57             self.camera.position = state.land.play_box().center();
    55 
    58 
    56             let theme =
    59             let theme =
    57                 Theme::load(Path::new("../../share/hedgewars/Data/Themes/Cheese/")).unwrap();
    60                 Theme::load(Path::new("../../share/hedgewars/Data/Themes/Cheese/")).unwrap();
    58             let texture = MapGenerator::new().make_texture(&state.land, &theme);
    61             let texture = MapGenerator::new().make_texture(&state.land, &theme);
    59             if let Some(ref mut renderer) = self.renderer {
    62             if let Some(ref mut renderer) = self.map_renderer {
    60                 renderer.init(&texture);
    63                 renderer.init(&texture);
    61             }
    64             }
    62         }
    65         }
    63     }
    66     }
    64 
    67 
   110             (position_shift.y as f32 / self.camera.zoom) as i32,
   113             (position_shift.y as f32 / self.camera.zoom) as i32,
   111         );
   114         );
   112     }
   115     }
   113 
   116 
   114     pub fn render(&mut self) {
   117     pub fn render(&mut self) {
   115         if let Some(ref mut renderer) = self.renderer {
   118         if let Some(ref mut renderer) = self.map_renderer {
   116             unsafe {
   119             unsafe {
   117                 gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
   120                 gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
   118                 gl::Clear(gl::COLOR_BUFFER_BIT);
   121                 gl::Clear(gl::COLOR_BUFFER_BIT);
   119             }
   122             }
   120 
   123 
   121             renderer.render(&self.camera);
   124             renderer.render(&self.camera);
       
   125         }
       
   126         if let Some(ref mut renderer) = self.gear_renderer {
       
   127             renderer.render(&self.camera)
   122         }
   128         }
   123     }
   129     }
   124 
   130 
   125     fn get_unused_gear_id(&mut self) -> GearId {
   131     fn get_unused_gear_id(&mut self) -> GearId {
   126         let id = self.last_gear_id;
   132         let id = self.last_gear_id;