hedgewars-draft: comparison rust/lib-hedgewars-engine/src/render/map.rs

equal deleted inserted replaced

-:12db7e435ea6
+:19122a329774
 use integral_geometry::{Point, Rect, Size};
-use land2d::{Land2D};
+use land2d::Land2D;
-use vec2d::{Vec2D};
+use vec2d::Vec2D;
 use super::gl::{
-Texture2D,
+Buffer, InputElement, InputFormat, InputLayout, Shader, Texture2D, VariableBinding,
-Buffer,
-Shader,
-InputLayout,
-VariableBinding,
-InputElement,
-InputFormat,
 };
 // TODO: temp
 const VERTEX_SHADER: &'static str = r#"
 #version 150
 tile_indices: Vec<u16>,
 tile_draw_calls: Vec<DrawTile>,
 index_offset: u16,
 tile_shader: Shader,
 tile_layout: InputLayout,
 tile_width: u32,
 tile_height: u32,
 num_tile_x: i32,
 }
 Some(PIXEL_SHADER),
 &[
 VariableBinding::Attribute("Position", 0),
 VariableBinding::Attribute("Uv", 1),
 VariableBinding::Sampler("Texture", 0),
-]
+],
-).unwrap();
+)
+.unwrap();
 let tile_layout = InputLayout::new(vec![
 // position
 InputElement {
 shader_slot: 0,
 buffer_slot: 0,
 format: InputFormat::Float(gl::FLOAT, false),
 components: 2,
 stride: 20,
-offset: 0
+offset: 0,
 },
 // uv
 InputElement {
 shader_slot: 1,
 buffer_slot: 0,
 format: InputFormat::Float(gl::FLOAT, false),
 components: 3,
 stride: 20,
-offset: 8
+offset: 8,
 },
 ]);
 MapRenderer {
 tiles: Vec::new(),
 textures: Vec::new(),
 tile_vertex_buffer: Buffer::empty(gl::ARRAY_BUFFER, gl::DYNAMIC_DRAW),
 tile_index_buffer: Buffer::empty(gl::ELEMENT_ARRAY_BUFFER, gl::DYNAMIC_DRAW),
 tile_vertices: Vec::new(),
 tile_indices: Vec::new(),
 index_offset: 0,
 let data = unsafe { &land.as_bytes()[offset..] };
 let stride = land.width();
 (data, stride as u32)
 };
 let texture_index = if idx >= self.textures.len() {
 let texture = Texture2D::with_data(
 data,
 stride,
 self.tile_width,
 self.tile_height,
 gl::RGBA8,
 gl::RGBA,
 gl::UNSIGNED_BYTE,
-gl::NEAREST
+gl::NEAREST,
 );
 let texture_index = self.textures.len();
 self.textures.push(texture);
 texture_index
 } else {
 let texture_region = Rect::new(
 Point::new(0, 0),
-Point::new(self.tile_width as i32, self.tile_height as i32)
+Point::new(self.tile_width as i32, self.tile_height as i32),
 );
-self.textures[idx].update(texture_region, data, stride, gl::RGBA, gl::UNSIGNED_BYTE);
+self.textures[idx].update(
+texture_region,
+data,
+stride,
+gl::RGBA,
+gl::UNSIGNED_BYTE,
+);
 idx
 };
 let tile = MapTile {
 texture_index: texture_index as u32,
 // TODO: are there ever non-power of two textures?
 width: self.tile_width,
 height: self.tile_height,
 };
 self.tiles.push(tile);
 }
 }
 }
-pub fn update(&mut self, land: &Land2D<u32>, region: Rect) {
+pub fn update(&mut self, land: &Land2D<u32>, region: Rect) {}
-}
 pub fn render(&mut self, viewport: Rect) {
 self.tile_vertices.clear();
 self.tile_indices.clear();
 self.tile_draw_calls.clear();
 self.index_offset = 0;
 for (idx, tile) in self.tiles.iter().enumerate() {
 let tile_x = idx as i32 % self.num_tile_x;
 let tile_y = idx as i32 / self.num_tile_x;
 let tile_w = self.tile_width as i32;
 let tile_h = self.tile_height as i32;
 let tile_w = tile_x + tile_w as f32;
 let tile_h = tile_y + tile_h as f32;
 let uv_depth = tile.texture_index as f32;
 //dbg!(tile_x);
-let tl = TileVertex { pos: [tile_x, tile_y], uv: [0f32, 0f32, uv_depth] };
+let tl = TileVertex {
-let bl = TileVertex { pos: [tile_x, tile_h], uv: [0f32, 1f32, uv_depth] };
+pos: [tile_x, tile_y],
-let br = TileVertex { pos: [tile_w, tile_h], uv: [1f32, 1f32, uv_depth] };
+uv: [0f32, 0f32, uv_depth],
-let tr = TileVertex { pos: [tile_w, tile_y], uv: [1f32, 0f32, uv_depth] };
+};
+let bl = TileVertex {
+pos: [tile_x, tile_h],
+uv: [0f32, 1f32, uv_depth],
+};
+let br = TileVertex {
+pos: [tile_w, tile_h],
+uv: [1f32, 1f32, uv_depth],
+};
+let tr = TileVertex {
+pos: [tile_w, tile_y],
+uv: [1f32, 0f32, uv_depth],
+};
 self.tile_vertices.extend(&[tl, bl, br, tr]);
 let i = self.index_offset;
-self.tile_indices.extend(&[
+self.tile_indices
-i + 0, i + 1, i + 2,
+.extend(&[i + 0, i + 1, i + 2, i + 2, i + 3, i + 0]);
-i + 2, i + 3, i + 0,
-]);
 self.index_offset += 4;
 self.tile_draw_calls.push(DrawTile {
 texture_index: tile.texture_index,
-index_len: 6
+index_len: 6,
 });
 }
 }
 self.tile_vertex_buffer.write_typed(&self.tile_vertices);
 self.tile_index_buffer.write_typed(&self.tile_indices);
-let _g = self.tile_layout.bind(&[
+let _g = self.tile_layout.bind(
-(0, &self.tile_vertex_buffer)
+&[(0, &self.tile_vertex_buffer)],
-], Some(&self.tile_index_buffer));
+Some(&self.tile_index_buffer),
+);
 let ortho = {
 let l = viewport.left() as f32;
 let r = viewport.right() as f32;
 let b = viewport.bottom() as f32;
 let t = viewport.top() as f32;
 [
-2f32 / (r - l),    0f32,              0f32,   0f32,
+2f32 / (r - l),
-0f32,              2f32 / (t - b),    0f32,   0f32,
+0f32,
-0f32,              0f32,              0.5f32, 0f32,
+0f32,
-(r + l) / (l - r), (t + b) / (b - t), 0.5f32, 1f32,
+0f32,
+0f32,
+2f32 / (t - b),
+0f32,
+0f32,
+0f32,
+0f32,
+0.5f32,
+0f32,
+(r + l) / (l - r),
+(t + b) / (b - t),
+0.5f32,
+1f32,
 ]
 };
 self.tile_shader.bind();
 self.tile_shader.set_matrix("Projection", ortho.as_ptr());
 let mut draw_offset = 0;
 for draw_call in &self.tile_draw_calls {
 unsafe {
-self.tile_shader.bind_texture_2d(0, &self.textures[draw_call.texture_index as usize]);
+self.tile_shader
+.bind_texture_2d(0, &self.textures[draw_call.texture_index as usize]);
 gl::DrawElements(
 gl::TRIANGLES,
 draw_call.index_len as i32,
 gl::UNSIGNED_SHORT,
-draw_offset as *const _
+draw_offset as *const _,
 );
 }
 draw_offset += draw_call.index_len * 2;
 }
 }
 }

changeset 14726	19122a329774
parent 14723	29dbe9ce8b7d
child 14735	4df1aac5f090