From 4c4b57dc24bc36b3091931c9dcc36f6b1894a017 Mon Sep 17 00:00:00 2001 From: Arne Dußin Date: Fri, 27 Nov 2020 22:55:00 +0100 Subject: Change to f64 as the preferred floating point number --- src/grid.rs | 38 +++++++++----------------------------- 1 file changed, 9 insertions(+), 29 deletions(-) (limited to 'src/grid.rs') diff --git a/src/grid.rs b/src/grid.rs index 72a849a..c885f19 100644 --- a/src/grid.rs +++ b/src/grid.rs @@ -4,7 +4,7 @@ use raylib::drawing::RaylibDraw; use raylib::ffi::Color; /// The internal grid length which will be used to snap things to it. -pub const SNAP_SIZE: f32 = 0.5; +pub const SNAP_SIZE: f64 = 0.5; pub const LINE_COLOUR: Color = Color { r: 255, @@ -15,7 +15,7 @@ pub const LINE_COLOUR: Color = Color { /// Snap a vector to the grid with the factor being the sub-grid accuracy. For instance, 0.5 will /// snap to half a grid cell, while 2.0 would snap to every second grid cell -pub fn snap_to_grid(mut vec: Vec2, snap_fraction: f32) -> Vec2 { +pub fn snap_to_grid(mut vec: Vec2, snap_fraction: f64) -> Vec2 { vec.x = math::round(vec.x, snap_fraction); vec.y = math::round(vec.y, snap_fraction); @@ -35,37 +35,17 @@ where let translation_y_px: i32 = transform.translation_px().y as i32 % transform.pixels_per_m() as i32; - /* - let mut row = 0; - loop { - let line_y = translation_y_px + (transform.pixels_per_m() * row as f32) as i32; - if line_y > screen_height { - break; - } - rld.draw_line(0, line_y as i32, screen_width, line_y as i32, LINE_COLOUR); - row += 1; - } - - let mut column = 0; - loop { - let line_x = translation_x_px + (transform.pixels_per_m() * column as f32) as i32; - if line_x > screen_width { - break; - } - rld.draw_line(line_x as i32, 0, line_x as i32, screen_height, LINE_COLOUR); - column += 1; - } - */ - - // Draw the row lines. - let mut line_y: f32 = translation_y_px as f32; - while line_y <= screen_height as f32 { + // Draw the row lines. Add back the subpixels to the translation + let mut line_y: f64 = translation_y_px as f64 + + (transform.translation_px().y - transform.translation_px().y as i32 as f64); + while line_y <= screen_height as f64 { rld.draw_line(0, line_y as i32, screen_width, line_y as i32, LINE_COLOUR); line_y += transform.pixels_per_m(); } // Draw the column lines. - let mut line_x: f32 = translation_x_px as f32; - while line_x <= screen_width as f32 { + let mut line_x: f64 = translation_x_px as f64 + + (transform.translation_px().x - transform.translation_px().x as i32 as f64); + while line_x <= screen_width as f64 { rld.draw_line(line_x as i32, 0, line_x as i32, screen_height, LINE_COLOUR); line_x += transform.pixels_per_m(); } -- cgit v1.2.3-70-g09d2 From 90db142588e1b78250dc9b266bae359cf9e22721 Mon Sep 17 00:00:00 2001 From: Arne Dußin Date: Sat, 28 Nov 2020 02:22:35 +0100 Subject: Limit grid inaccuracy to half a pixel Before, the grid was calculated accumutatively, which was pretty alright. However, with some zoom levels towards the bottom of the screen there was a discrepancy between the grid and something drawn. This should be fixed now, since this update makes the grid use the same method of calculation for every grid cell that everything else uses to calculate points. Also, sub-pixel positions are rounded for the grid, while they were floored before, which should improve accuracy. --- src/grid.rs | 47 ++++++++++++++++++++++++++++------------------- 1 file changed, 28 insertions(+), 19 deletions(-) (limited to 'src/grid.rs') diff --git a/src/grid.rs b/src/grid.rs index c885f19..ec27fa7 100644 --- a/src/grid.rs +++ b/src/grid.rs @@ -27,26 +27,35 @@ pub fn draw_grid(rld: &mut D, screen_width: i32, screen_height: i32, transfor where D: RaylibDraw, { - /* Calculate the actual screen offset of the grid, by modulo-ing the translation of the - * transform. + /* Calculate the first whole meter that can be seen on the grid. This is the first meter that + * will be seen on screen. */ - let translation_x_px: i32 = - transform.translation_px().x as i32 % transform.pixels_per_m() as i32; - let translation_y_px: i32 = - transform.translation_px().y as i32 % transform.pixels_per_m() as i32; - - // Draw the row lines. Add back the subpixels to the translation - let mut line_y: f64 = translation_y_px as f64 - + (transform.translation_px().y - transform.translation_px().y as i32 as f64); - while line_y <= screen_height as f64 { - rld.draw_line(0, line_y as i32, screen_width, line_y as i32, LINE_COLOUR); - line_y += transform.pixels_per_m(); + let mut first_cell = *transform.translation_px() / -transform.pixels_per_m(); + first_cell.x = first_cell.x.floor(); + first_cell.y = first_cell.y.floor(); + + let mut cell = first_cell; + let mut draw_y = transform.point_m_to_px(&cell).y; + loop { + draw_y = math::round(draw_y, 1.); + rld.draw_line(0, draw_y as i32, screen_width, draw_y as i32, LINE_COLOUR); + cell.y += 1.; + draw_y = transform.point_m_to_px(&cell).y; + + if draw_y as i32 > screen_height { + break; + } } - // Draw the column lines. - let mut line_x: f64 = translation_x_px as f64 - + (transform.translation_px().x - transform.translation_px().x as i32 as f64); - while line_x <= screen_width as f64 { - rld.draw_line(line_x as i32, 0, line_x as i32, screen_height, LINE_COLOUR); - line_x += transform.pixels_per_m(); + + let mut draw_x = transform.point_m_to_px(&cell).x; + loop { + draw_x = math::round(draw_x, 1.); + rld.draw_line(draw_x as i32, 0, draw_x as i32, screen_height, LINE_COLOUR); + cell.x += 1.; + draw_x = transform.point_m_to_px(&cell).x; + + if draw_x as i32 > screen_width { + break; + } } } -- cgit v1.2.3-70-g09d2