.

t/src/canvas/_draw.rs

@@ -0,0 +1,132 @@
+use std::cmp::min;
+use eframe::egui;
+use eframe::egui::Color32;
+use image::{GenericImage, Pixel, Rgb, Rgba};
+use rusttype::{point, Font, Scale};
+use crate::canvas::Canvas;
+
+impl Canvas {
+
+    pub fn text_center(
+        &mut self,
+        font: &Font,
+        color: egui::Color32,
+        x: f32,
+        y: f32,
+        text: &str,
+        scale: Scale,
+    ) {
+        self.refresh();
+
+        let v_metrics = font.v_metrics(scale);
+
+        let glyphs: Vec<_> = font
+            .layout(text, scale, point(0.0, 0.0 + v_metrics.ascent))
+            .collect();
+
+        let (width, height) = {
+            let mut min_x = i32::MAX;
+            let mut min_y = i32::MAX;
+            let mut max_x = i32::MIN;
+            let mut max_y = i32::MIN;
+
+            for g in glyphs.iter()
+                .map(|p|p.pixel_bounding_box())
+                .flatten() {
+                min_x = min_x.min(g.min.x);
+                min_y = min_y.min(g.min.y);
+                max_x = max_x.max(g.max.x);
+                max_y = max_y.max(g.max.y);
+                // self.debug_rect(
+                //     Color32::GREEN,
+                //     g.min.x as _,
+                //     g.min.y as _,
+                //     g.max.x as _,
+                //     g.max.y as _,
+                //     );
+            }
+            
+            // self.debug_rect(
+            //     Color32::PURPLE,
+            //     min_x as _, min_y as _,
+            //     max_x as _, max_y as _);
+            ((max_x/* - min_x*/) as f32,
+             (max_y/* - min_y*/) as f32)
+        };
+        let (x, y) = (
+            x - (width / 2.0),
+            y - (height / 2.0)
+        );
+
+        // self.debug_rect(Color32::RED, x, y, x + width, y + height);
+
+        let glyphs: Vec<_> = font
+            .layout(text, scale, point(x, y + v_metrics.ascent))
+            .collect();
+
+        for glyph in glyphs {
+            if let Some(bounding_box) = glyph.pixel_bounding_box() {
+
+                // self.debug_rect(
+                //     Color32::RED,
+                //     bounding_box.min.x as _,
+                //     bounding_box.min.y as _,
+                //     bounding_box.max.x as _,
+                //     bounding_box.max.y as _);
+
+                glyph.draw(|x, y, v| {
+                    let p = self.image.get_pixel_mut(
+                        x + bounding_box.min.x as u32,
+                        y + bounding_box.min.y as u32,
+                    );
+
+                    let mut op = p.to_rgba();
+                    let np = Rgba([
+                        color.r(),
+                        color.g(),
+                        color.b(),
+                        (color.a() as f32 * v) as u8
+                    ]);
+                    op.blend(&np);
+                    *p = op.to_rgb()
+                });
+            }
+        }
+
+    }
+
+    fn debug_rect(
+        &mut self,
+        color: Color32,
+        mnx: f32,
+        mny: f32,
+        mxx: f32,
+        mxy: f32,
+    ) {
+        self.refresh();
+
+        // sort the values just in case
+        let (mnx, mxx) = (mnx.min(mxx), mxx.max(mxx));
+        let (mny, mxy) = (mny.min(mxy), mxy.max(mxy));
+
+        let rgb = Rgb([
+            color.r(),
+            color.g(),
+            color.b(),
+        ]);
+
+        let w = (mxx - mnx) as u32;
+        let h = (mxy - mny) as u32;
+        for w in 0..w {
+            self.image.put_pixel(mnx as u32 + w, mny as u32, rgb);
+            self.image.put_pixel(mnx as u32 + w, mxy as u32, rgb);
+            self.image.put_pixel(mnx as u32 + w, mny as u32 + h, rgb);
+
+        }
+        for h in 0..h {
+            self.image.put_pixel(mnx as u32, mny as u32 + h, rgb);
+            self.image.put_pixel(mxx as u32, mny as u32 + h, rgb);
+        }
+    }
+
+}