Final version of runner game

src/engine/generic_object.rs

@@ -1,8 +1,8 @@
-use engine::generic_object_type::GenericObjectType;
+use engine::generic_object_type::GenericSpriteType;
 
 pub trait GenericObject{
  //fn key_reader(&self, key: &str);
- fn get_type(&self) -> GenericObjectType;
+ fn get_type(&self) -> GenericSpriteType;
  fn get_position(&self) -> (f32,f32,f32);
  fn get_name(&self) -> String;
  fn get_description(&self) -> String;
@@ -15,7 +15,7 @@ pub trait GenericObject{
 impl <F: ?Sized> GenericObject for Box<F>
  where F: GenericObject
 {
- fn get_type(&self) -> GenericObjectType {
+ fn get_type(&self) -> GenericSpriteType {
  (**self).get_type()
  }
 

src/engine/generic_object_type.rs

@@ -1,4 +1,4 @@
-pub enum GenericObjectType {
+pub enum GenericSpriteType {
  SPRITE,
  TEXT,
 }

src/engine/graphics_handler.rs

@@ -14,7 +14,39 @@ impl GraphicsHandler {
  objects_textures: &glium::texture::Texture2dArray,
  ui_texture: &glium::texture::Texture2d,
  program: &Vec<glium::program::Program>,
- frame_buffer: &mut glium::framebuffer::SimpleFrameBuffer) {
+ frame_buffer: &mut glium::framebuffer::SimpleFrameBuffer,
+ thirdd_buffers: (glium::VertexBuffer<Vertex>, glium::IndexBuffer<u16>)) {
+ //--------------------------3D-DRAW-START---------------------------//
+ let thirdd_vertex_buffer = thirdd_buffers.0;
+ let thirdd_index_buffer = thirdd_buffers.1;
+
+ let zfar = 1024.0;
+ let znear = 0.1;
+
+ let aspect_ratio = 600.0/800.0;
+ let fov: f32 = 3.141592/3.0;
+ let f = 1.0 / (fov / 2.0).tan();
+
+ let thirdd_uniform = uniform!(
+ matrix: [
+ [600.0/800.0, 0.0, 0.0 , 0.0],
+ [ 0.0 , f , 0.0 , 0.0],
+ [ 0.0 , 0.0, (zfar+znear)/(zfar-znear), 0.0],
+ [ 0.0 , 0.0, -(2.0*zfar*znear)/(zfar-znear), 0.0],
+ ]
+ );
+
+ let thirdd_params = glium::DrawParameters {
+ blend: glium::Blend::alpha_blending(),
+
+ ..Default::default()
+ };
+
+ frame_buffer.clear_color(1.0f32, 1.0f32, 1.0f32, 1.0f32);
+ frame_buffer.draw(&thirdd_vertex_buffer, &thirdd_index_buffer, &program[1], &thirdd_uniform, &thirdd_params ).unwrap();
+
+ //---------------------------3D-DRAW-END----------------------------//
+
  //--------------------------UI-DRAW-START---------------------------//
  let ui_vertex_buffer = ui_buffers.0;
  let ui_index_buffer = ui_buffers.1;

src/engine/mod.rs

@@ -23,3 +23,5 @@ pub mod generic_control;
 pub mod generic_object_type;
 pub mod frame_buffer_manager;
 pub mod layer_type;
+pub mod model;
+pub mod object_manager;

src/engine/model.rs

@@ -3,8 +3,8 @@ use engine::graphic_item::GraphicItem;
 
 #[derive(Clone, Debug)]
 pub struct Model {
- pub vertices: [Vertex; 6],
- pub indices: [u16; 6],
+ pub vertices: Vec<Vertex>,
+ pub indices: Vec<u16>,
  pub name: String
 }
 
@@ -14,59 +14,59 @@ impl Model {
  y:f32,
  z:f32,
  color: [f32; 4],
- size: (f23, f32, f32)) -> Model {
+ size: (f32, f32, f32)) -> Model {
  Model {
- vertices: [
+ vertices: vec![
  Vertex {
  position: [-0.5 * size.0 + x, 0.5 * size.1 + y,0.5* size.2 - z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.0 .0, tex_coord.0 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [0.5 * size.0 + x, 0.5 * size.1 + y,0.5* size.2 - z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.1 .0, tex_coord.1 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [0.5 * size.0 + x, -0.5 * size.1 + y,0.5* size.2 - z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.2 .0, tex_coord.2 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [-0.5 * size.0 + x, -0.5 * size.1 + y,0.5* size.2 - z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.3 .0, tex_coord.3 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [-0.5 * size.0 + x, 0.5 * size.1 + y,0.5* size.2 + z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.0 .0, tex_coord.0 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [0.5 * size.0 + x, -0.5 * size.1 + y,0.5* size.2 + z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.2 .0, tex_coord.2 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  },
  Vertex {
  position: [-0.5 * size.0 + x, -0.5 * size.1 + y,0.5* size.2 + z],
  normal: [0.0, 0.0, -1.0],
  color: color,
- tex_coords: [tex_coord.3 .0, tex_coord.3 .1],
- i_tex_id: tex_id,
+ tex_coords: [0.0, 0.0],
+ i_tex_id: 0,
  }],
- indices: [0,1,2,
+ indices: vec![0,1,2,
  0,2,3,
  1,4,5,
  1,5,2,

src/engine/modules_manager.rs

@@ -1,13 +1,17 @@
 extern crate glium;
+
 use engine::sprite::Sprite;
 use engine::shader_manager::Shaders;
 use engine::sprite_manager::SpriteManager;
 use engine::graphics_handler::GraphicsHandler;
 use engine::generic_object::GenericObject;
 use engine::generic_control::GenericControl;
 use engine::text_writer::TextWriter;
-use engine::generic_object_type::GenericObjectType;
+use engine::generic_object_type::GenericSpriteType;
 use engine::input_manager::InputManager;
+use engine::model::Model;
+use engine::object_manager::ObjectManager;
+use engine::vertex;
 
 pub struct ModulesManager<'a> {
  display: &'a glium::backend::glutin_backend::GlutinFacade,
@@ -18,21 +22,20 @@ pub struct ModulesManager<'a> {
 
 impl<'a> ModulesManager<'a> {
  pub fn new(display: &glium::backend::glutin_backend::GlutinFacade) -> ModulesManager {
-
  let mut shaders = Shaders::new(vec![&include_bytes!("../../content/VFKM2.png")[..],
- &include_bytes!("../../content/11532.png")[..],
- &include_bytes!("../../content/NatureForests.png")[..],
- &include_bytes!("../../content/hero.png")[..],
- &include_bytes!("../../content/background.png")[..],
- &include_bytes!("../../content/game_over.png")[..]],
+  &include_bytes!("../../content/11532.png")[..],
+  &include_bytes!("../../content/NatureForests.png")[..],
+  &include_bytes!("../../content/hero.png")[..],
+  &include_bytes!("../../content/background.png")[..],
+  &include_bytes!("../../content/game_over.png")[..]],
  &display);
 
 
  shaders.compile_shaders(&display);
 
  let frame_texture = glium::texture::Texture2d::empty_with_format(display,
- glium::texture::UncompressedFloatFormat::F32F32F32F32,
- glium::texture::MipmapsOption::NoMipmap, 800,600).unwrap();
+  glium::texture::UncompressedFloatFormat::F32F32F32F32,
+  glium::texture::MipmapsOption::NoMipmap, 800, 600).unwrap();
  let textures = shaders.get_texture_array(&display);
  ModulesManager {
  display: display,
@@ -48,18 +51,22 @@ impl<'a> ModulesManager<'a> {
  generics_objects: &Vec<Box<GenericObject>>,
  generics_controls: Vec<Box<GenericControl>>,
  ui_texture: &glium::texture::Texture2d,
- frame_buffer: &mut glium::framebuffer::SimpleFrameBuffer)
- -> (&ModulesManager, Vec<&str>) {
-
- let bunch_of_generic_sprite_objects =
- self.generic_sprite_object_interpretor(generics_objects).get_buffers(self.display);
- GraphicsHandler::draw(&self.display,
- bunch_of_generic_sprite_objects,
- &self.textures,
- ui_texture,
- &self.program,
- frame_buffer);
- (self, InputManager::get_input(self.display))
+ frame_buffer: &mut glium::framebuffer::SimpleFrameBuffer,
+ thirdd_objects: Vec<(f32, f32, f32)>)
+ -> (&ModulesManager, Vec<&str>) {
+
+ let bunch_of_generic_sprite_objects =
+ self.generic_sprite_object_interpretor(generics_objects).get_buffers( self.display);
+
+ let bunch_of_thirdd_objects = self.thirdd_object_interpretor(thirdd_objects);
+ GraphicsHandler::draw( & self.display,
+ bunch_of_generic_sprite_objects,
+ & self.textures,
+ ui_texture,
+ & self.program,
+ frame_buffer,
+ bunch_of_thirdd_objects);
+ ( self, InputManager::get_input( self.display))
  }
 
  pub fn generic_sprite_object_interpretor(&self,
@@ -69,7 +76,7 @@ impl<'a> ModulesManager<'a> {
  let mut name: String;
  let mut position: (f32, f32, f32);
  let mut description: String;
- let mut texture_coordinates: ((f32,f32),(f32,f32),(f32,f32),(f32,f32));
+ let mut texture_coordinates: ((f32, f32), (f32, f32), (f32, f32), (f32, f32));
  let mut order: u8;
  //TODO Ajouter un ordonnanceur de sprites
  for i in generic_object {
@@ -80,7 +87,7 @@ impl<'a> ModulesManager<'a> {
  order = i.get_order();
 
  match i.get_type() {
- GenericObjectType::SPRITE => {
+ GenericSpriteType::SPRITE => {
  result_vec.push(Sprite::new(name,
  position.0,
  position.1,
@@ -91,7 +98,7 @@ impl<'a> ModulesManager<'a> {
  order));
  }
 
- GenericObjectType::TEXT => {
+ GenericSpriteType::TEXT => {
  let text_writer = TextWriter::new(0,
  (256, 256),
  (16, 16),
@@ -101,28 +108,36 @@ impl<'a> ModulesManager<'a> {
  true, order);
  result_vec.extend_from_slice(&text_writer.get_string(description.as_str()));
  }
-
  }
-
  }
- result_vec.sort_by(|a,b| a.order.cmp(&b.order));
+ result_vec.sort_by(|a, b| a.order.cmp(&b.order));
  SpriteManager::new(result_vec)
  }
+
+ pub fn thirdd_object_interpretor(&self, thirdd_objects: Vec<(f32, f32, f32)>) -> (glium::VertexBuffer<vertex::Vertex>, glium::IndexBuffer<u16>) {
+ let mut result_vec = Vec::new();
+
+ for e in thirdd_objects {
+ result_vec.push(Model::new("cube".to_string(),e.0, e.1, e.2,[1.0, 0.0, 0.0, 0.0],(0.1, 0.1, 0.1)));
+ }
+ ObjectManager::get_buffers(&self.display, result_vec)
+ }
 }
 
 #[cfg(test)]
 mod tests {
  use super::*;
  use engine::generic_object::GenericObject;
- use engine::generic_object_type::GenericObjectType;
+ use engine::generic_object_type::GenericSpriteType;
 
  #[derive(Debug)]
  struct ObjTest {
  size: i32,
  }
+
  impl GenericObject for ObjTest {
- fn get_type(&self) -> GenericObjectType {
- GenericObjectType::SPRITE
+ fn get_type(&self) -> GenericSpriteType {
+ GenericSpriteType::SPRITE
  }
 
  fn get_position(&self) -> (f32, f32, f32) {
@@ -140,8 +155,8 @@ mod tests {
  fn get_size(&self) -> (f32, f32, f32) {
  (0.0, 0.0, 0.0)
  }
- fn  get_texture_coordinates(&self) ->((f32,f32),(f32,f32)){
- ((0.0,0.0),(0.0,0.0))
+ fn get_texture_coordinates(&self) -> ((f32, f32), (f32, f32)) {
+ ((0.0, 0.0), (0.0, 0.0))
  }
  }
 }

src/engine/object_manager.rs

@@ -0,0 +1,35 @@
+use engine::model::Model;
+use engine::vertex;
+
+extern crate glium;
+
+#[derive(Clone, Debug)]
+pub struct ObjectManager {}
+
+impl ObjectManager {
+ pub fn get_buffers(display: &glium::backend::glutin_backend::GlutinFacade, models: Vec<Model>) ->
+ (glium::VertexBuffer<vertex::Vertex>, glium::IndexBuffer<u16>) {
+ let mut vertice_array = Vec::new();
+ for model in &models {
+ for vertex in model.vertices.iter() {
+ vertice_array.push(*vertex);
+ }
+ }
+
+ let mut indice_array = Vec::new();
+ let mut iterator: u16 = 0;
+ for model in &models {
+ let offset = model.indices.len() as u16;
+ for index in model.clone().indices {
+ indice_array.push(index + offset * iterator );
+ }
+ iterator = iterator + 1;
+ }
+
+ (glium::VertexBuffer::dynamic(display, &vertice_array).unwrap(),
+ glium::index::IndexBuffer::new(display,
+ glium::index::PrimitiveType::TrianglesList,
+ &indice_array)
+ .unwrap())
+ }
+}

src/game_logic/actor.rs

@@ -1,5 +1,5 @@
 use engine::generic_object::GenericObject;
-use engine::generic_object_type::GenericObjectType;
+use engine::generic_object_type::GenericSpriteType;
 
 #[derive(Clone, Debug)]
 pub struct Actor {
@@ -25,8 +25,8 @@ impl Actor {
 }
 
 impl GenericObject for Actor {
- fn get_type(&self) -> GenericObjectType {
- GenericObjectType::SPRITE
+ fn get_type(&self) -> GenericSpriteType {
+ GenericSpriteType::SPRITE
  }
  fn get_position(&self) -> (f32, f32, f32) {
  (self.position[0], self.position[1], 0.0)
@@ -56,7 +56,7 @@ impl GenericObject for Actor {
 #[cfg(test)]
 mod tests {
  use super::*;
- use engine::generic_object_type::GenericObjectType;
+ use engine::generic_object_type::GenericSpriteType;
 
 
  fn get_actor() -> Actor {
@@ -88,6 +88,6 @@ mod tests {
  fn should_get_type() {
  let actor = get_actor();
 
- assert_eq!(actor.get_type(), GenericObjectType::SPRITE);
+ assert_eq!(actor.get_type(), GenericSpriteType::SPRITE);
  }
 }