add better brush drawing feedback

1 files changed, 69 insertions, 38 deletions

diff --git a/src/app.rs b/src/app.rs
index 7bca6ba..42e63de 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,5 +1,5 @@
 use crate::{
-    bitmap::{MapPoint, Pixmap},
+    bitmap::{positive_angle_with_x, MapPoint, Pixmap},
     brush::Brush,
     command::CommandBox,
     consts::{colors::*, FONT_PATH},
@@ -35,7 +35,6 @@ pub enum Mode {
 
 pub struct AppState<'ctx, 'file> {
     pub active_color: bool,
-    pub brush_size: u8,
     pub brush: Brush,
     pub canvas: Canvas<Window>,
     pub command_box: CommandBox,
@@ -146,8 +145,9 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         &mut self,
         center: P,
         val: bool,
+        brush_size: u8,
     ) -> Result<Vec<ModifyRecord>, ()> {
-        let radius = self.brush_size as u32;
+        let radius = brush_size as u32;
         let center = self.idx_at_coord(center).ok_or(())?;
         let dither_level = self.dither_level;
 
@@ -172,6 +172,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         start: MapPoint,
         end: P,
         val: bool,
+        brush_size: u8,
     ) -> Result<Vec<ModifyRecord>, ()> {
         let MapPoint { x, y } = start;
         let end = self.idx_at_coord(end).ok_or(())?;
@@ -182,7 +183,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
 
         let mut line_modify_record = vec![];
         for point in line.into_iter().chain(sym_line) {
-            let circle_around_point = self.pixmap.get_circle(point, self.brush_size as u32, true);
+            let circle_around_point = self.pixmap.get_circle(point, brush_size as u32, true);
             for c in circle_around_point
                 .into_iter()
                 .filter(|&pt| dither::bayer(dither_level, pt))
@@ -257,15 +258,15 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         );
     }
 
-    pub fn increase_brush_size(&mut self) {
-        self.brush_size += 1;
-    }
+    // pub fn increase_brush_size(&mut self) {
+    //     self.brush_size += 1;
+    // }
 
-    pub fn decrease_brush_size(&mut self) {
-        if self.brush_size > 0 {
-            self.brush_size -= 1;
-        }
-    }
+    // pub fn decrease_brush_size(&mut self) {
+    //     if self.brush_size > 0 {
+    //         self.brush_size -= 1;
+    //     }
+    // }
 
     pub fn reduce_intensity(&mut self) {
         if self.dither_level > 0 {
@@ -343,9 +344,8 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
             format!("---, ---")
         };
         let status_text = format!(
-            "[DITHER {}][BRUSH {}][SYM {}][PT {}][ACTIVE {}][KIND {}]",
+            "[DITHER {}][SYM {}][PT {}][ACTIVE {}][KIND {}]",
             self.dither_level,
-            self.brush_size + 1,
             self.symmetry,
             mouse_coords,
             if self.active_color { "WHT" } else { "BLK" },
@@ -405,22 +405,51 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
     }
 
     fn draw_mouse(&mut self) {
-        let brush_size = self.brush_size;
         let cs = self.zoom as u32;
         let pt = self.idx_at_coord(self.mouse);
-        if let Some(center) = pt {
-            let circle = self.pixmap.get_circle(center, brush_size as u32, false);
-            for MapPoint { x, y } in circle.into_iter() {
-                self.canvas.set_draw_color(PINK);
-                self.canvas
-                    .fill_rect(Rect::new(
-                        x as i32 * cs as i32 + self.start.x(),
-                        y as i32 * cs as i32 + self.start.y(),
-                        cs,
-                        cs,
-                    ))
-                    .unwrap();
+        if matches!(self.brush, Brush::Circle { .. } | Brush::Line { .. }) {
+            let size = self.brush.size().unwrap();
+            if let Some(center) = pt {
+                let circle = self.pixmap.get_circle(center, size as u32, false);
+                for MapPoint { x, y } in circle.into_iter() {
+                    self.canvas.set_draw_color(PINK);
+                    self.canvas
+                        .fill_rect(Rect::new(
+                            x as i32 * cs as i32 + self.start.x(),
+                            y as i32 * cs as i32 + self.start.y(),
+                            cs,
+                            cs,
+                        ))
+                        .unwrap();
+                }
+            }
+        }
+        match self.brush {
+            Brush::Line { start, size, .. } => {
+                let size = self.zoom as u32 * size as u32;
+                if let (Some(from), Some(to)) = (start, pt) {
+                    let line = self.pixmap.get_line(from, to.into());
+                    draw_text(
+                        &mut self.canvas,
+                        self.ttf_context,
+                        format!("{}°", positive_angle_with_x(from, to.into())),
+                        PINK,
+                        (self.mouse.0 as u32 + size, self.mouse.1 as u32 + size),
+                    );
+                    for MapPoint { x, y } in line.into_iter() {
+                        self.canvas.set_draw_color(PINK);
+                        self.canvas
+                            .fill_rect(Rect::new(
+                                x as i32 * cs as i32 + self.start.x(),
+                                y as i32 * cs as i32 + self.start.y(),
+                                cs,
+                                cs,
+                            ))
+                            .unwrap();
+                    }
+                }
             }
+            _ => {}
         }
     }
 
@@ -485,9 +514,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         ev.push_event(Event::Quit { timestamp: 0u32 })
             .expect("ohno unable to quit");
     }
-}
 
-impl<'ctx, 'file> AppState<'ctx, 'file> {
     pub fn init(
         width: u32,
         height: u32,
@@ -499,7 +526,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         let video_subsystem = context.video().unwrap();
 
         let window = video_subsystem
-            .window("Pixel editor", 200, 200)
+            .window("Pixel editor", 500, 500)
             .position_centered()
             .resizable()
             .opengl()
@@ -517,8 +544,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
         let pixmap = Pixmap::new_with(width, height, data);
         Self {
             active_color: true,
-            brush_size: 0,
-            brush: Brush::new(),
+            brush: Brush::new(0),
             canvas,
             command_box: CommandBox::new(),
             context,
@@ -594,8 +620,8 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
                                         self.zoom_out(cursor);
                                     }
                                     // brush ops
-                                    Keycode::Q => self.decrease_brush_size(),
-                                    Keycode::E => self.increase_brush_size(),
+                                    Keycode::Q => self.brush.shrink(),
+                                    Keycode::E => self.brush.grow(),
                                     Keycode::Num1 => self.reduce_intensity(),
                                     Keycode::Num3 => self.increase_intensity(),
                                     // flip color
@@ -650,7 +676,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
                                 };
                                 match self.brush {
                                     Brush::Circle { size } => {
-                                        if let Ok(o) = self.paint_point(pt, val) {
+                                        if let Ok(o) = self.paint_point(pt, val, size) {
                                             self.current_operation.extend(o);
                                         }
                                     }
@@ -666,7 +692,7 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
                                                 extend,
                                             };
                                         } else if let Ok(o) =
-                                            self.paint_line(start.unwrap(), pt, val)
+                                            self.paint_line(start.unwrap(), pt, val, size)
                                         {
                                             self.current_operation.extend(o);
                                             self.brush = Brush::Line {
@@ -705,16 +731,21 @@ impl<'ctx, 'file> AppState<'ctx, 'file> {
                             Event::MouseMotion {
                                 x, y, mousestate, ..
                             } => {
+                                let size = match self.brush {
+                                    Brush::Circle { size } => size,
+                                    Brush::Line { size, .. } => size,
+                                    _ => continue,
+                                };
                                 if mousestate.is_mouse_button_pressed(MouseButton::Left) {
                                     let pt = (x, y);
                                     let val = self.active_color;
-                                    if let Ok(o) = self.paint_point(pt, val) {
+                                    if let Ok(o) = self.paint_point(pt, val, size) {
                                         self.current_operation.extend(o);
                                     }
                                 } else if mousestate.is_mouse_button_pressed(MouseButton::Right) {
                                     let pt = (x, y);
                                     let val = !self.active_color;
-                                    if let Ok(o) = self.paint_point(pt, val) {
+                                    if let Ok(o) = self.paint_point(pt, val, size) {
                                         self.current_operation.extend(o);
                                     }
                                 }