feat: add blit, lines

Author: lewisfm

Cargo.lock

@@ -14,6 +14,7 @@ softbuffer = "0.4.8"
 tracing = "0.1.44"
 vex-sdk = "0.28.0"
 winit = "0.30.12"
+embedded-graphics = { version = "0.8.2", default-features = false }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 dispatch2 = "0.3.1"
@@ -23,5 +24,6 @@ objc2-app-kit = { version = "0.3.2", features = ["objc2-core-graphics", "NSImage
 objc2-core-graphics = { version = "0.3.2", features = ["CGDataProvider", "CGColorSpace"] }
 
 [dev-dependencies]
+tinybmp = "0.7.0"
 tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
 vexide = { version = "0.8.0", features = ["full"] }

Cargo.toml

@@ -1,10 +1,19 @@
-use std::{thread, time::Duration};
+use std::{
+    f64::consts::{PI, TAU},
+    thread,
+    time::Duration,
+};
 
+use embedded_graphics::{
+    pixelcolor::{Rgb888, raw::RawU24},
+    prelude::RawData,
+};
+use tinybmp::Bmp;
 use tracing_subscriber::EnvFilter;
 use vex_sdk_desktop::sdk::*;
 
 fn main() {
-    // e.g. RUST_LOG=debug,vex_sdk_sim=trace
+    // e.g. RUST_LOG=debug,vex_sdk_desktop=trace
     tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .init();
@@ -31,6 +40,27 @@ fn main() {
         vexDisplayCircleDraw(150, 100, 10);
         vexDisplayCircleFill(180, 100, 10);
 
+        const AIRPLANE: &[u8] = include_bytes!("airplane.bmp");
+        let bmp = Bmp::<Rgb888>::from_slice(AIRPLANE).unwrap();
+        let img_data = bmp
+            .pixels()
+            .map(|p| RawU24::from(p.1).into_inner())
+            .collect::<Vec<u32>>();
+        let width = bmp.as_raw().header().image_size.width;
+
+        let offset = 200 * width + 325;
+
+        unsafe {
+            vexDisplayCopyRect(
+                20,
+                150,
+                100,
+                220,
+                img_data.as_ptr().cast_mut().wrapping_add(offset as usize),
+                width as i32,
+            );
+        }
+
         let mut velocity = 0.0;
         let mut position = -50.0;
         loop {
@@ -44,6 +74,22 @@ fn main() {
             vexDisplayForegroundColor(0x00_FF_00);
             vexDisplayCircleFill(210, y, 10);
 
+            let angle = (position / 50.0 + 1.0) * PI;
+            let (y, x) = angle.sin_cos();
+            println!("({x}, {y})");
+
+            let x1 = 250 + (x * 20.0) as i32;
+            let x2 = 250 - (x * 20.0) as i32;
+
+            let y1 = 100 + (y * 20.0) as i32;
+            let y2 = 100 - (y * 20.0) as i32;
+
+            vexDisplayForegroundColor(0xFF_FF_FF);
+            vexDisplayCircleFill(250, 100, 20);
+            vexDisplayForegroundColor(0x00_00_00);
+            println!("{:?}", (x1, y1, x2, y2));
+            vexDisplayLineDraw(x1, y1, x2, y2);
+
             vexDisplayRender(true, false);
         }
     })

examples/airplane.bmp

@@ -2,17 +2,11 @@ use std::{
     fmt::{self, Formatter},
     mem,
     ops::RangeInclusive,
-    sync::atomic::AtomicBool,
 };
 
 use line_drawing::{Bresenham, BresenhamCircle};
 use parking_lot::Mutex;
-use tracing::{debug, info, trace};
-
-use crate::{
-    SIM_APP, SimEvent,
-    display::{SimDisplay, SimDisplayWindow},
-};
+use tracing::trace;
 
 pub const WIDTH: u32 = 480;
 pub const HEIGHT: u32 = 272;
@@ -26,13 +20,13 @@ pub const HEADER_COLOR: u32 = 0x00_99_CC;
 /// The canvas instance used by user code.
 pub static CANVAS: Mutex<Canvas> = Mutex::new(Canvas::new());
 
-/// Indicates whether the render thread should automatically render the [user canvas](CANVAS).
-pub static AUTORENDER: AtomicBool = AtomicBool::new(true);
-
 #[derive(Debug, Clone, Copy)]
 pub struct CanvasState {
     pub fg_color: u32,
     pub bg_color: u32,
+    // This doesn't seem to affect any operations, but we store it so we can return it from
+    // `vexDisplayPenSizeGet`.
+    pub pen_size: u32,
     clip_region: Rect,
 }
 
@@ -45,6 +39,10 @@ impl CanvasState {
         region.clip_to(&Rect::FULL_CLIP);
         self.clip_region = region;
     }
+
+    pub fn clip_region(&self) -> Rect {
+        self.clip_region
+    }
 }
 
 pub struct Canvas {
@@ -59,6 +57,7 @@ impl Canvas {
             fg_color: DEFAULT_FG_COLOR,
             bg_color: DEFAULT_BG_COLOR,
             clip_region: Rect::FULL_CLIP,
+            pen_size: 1,
         };
 
         Self {
@@ -96,7 +95,7 @@ impl Canvas {
         let clip = self.state.clip_region;
 
         // Is the line above or below the clip region?
-        if !(clip.0.y..=clip.1.y).contains(&y) {
+        if !(clip.0.y..clip.1.y).contains(&y) {
             return;
         }
 
@@ -117,7 +116,7 @@ impl Canvas {
         let clip = self.state.clip_region;
 
         // Is the line left or right of the clip region?
-        if !(clip.0.x..=clip.1.x).contains(&x) {
+        if !(clip.0.x..clip.1.x).contains(&x) {
             return;
         }
 
@@ -132,6 +131,14 @@ impl Canvas {
         }
     }
 
+    pub fn draw_line(&mut self, start: Point, end: Point) {
+        trace!(?start, ?end, "line");
+
+        for (x, y) in Bresenham::new((start.x, start.y), (end.x, end.y)) {
+            self.set_pixel(Point { x, y });
+        }
+    }
+
     pub fn fill_rect(&mut self, mut bounds: Rect) {
         trace!(color = %Hex(self.state.fg_color), ?bounds, "fill rect");
 
@@ -174,7 +181,7 @@ impl Canvas {
         let mut lines = vec![(center.x, center.x); num_lines as usize];
 
         for (dx, i) in BresenhamCircle::new(0, radius as i32, radius as i32) {
-            let x = center.x as i32 + dx;
+            let x = center.x + dx;
 
             // The tops and bottoms of circles have several points on the same line, so only record
             // the leftmost or rightmost point for our horizontal line.
@@ -205,13 +212,27 @@ impl Canvas {
 
         let clip = self.state.clip_region;
 
-        for (x, y) in BresenhamCircle::new(center.x as i32, center.y as i32, radius as i32) {
+        for (x, y) in BresenhamCircle::new(center.x, center.y, radius as i32) {
             if (Point { x, y }).is_inside(&clip) {
                 self.write_pixel(Point { x, y }, self.state.fg_color);
             }
         }
     }
 
+    pub unsafe fn copy_rect(&mut self, mut bounds: Rect, source: *const u32, stride: usize) {
+        trace!(?bounds, ?source, ?stride, "copy rect");
+        bounds.clip_to(&self.state.clip_region);
+
+        for (row_idx, row) in (bounds.0.y..bounds.1.y).enumerate() {
+            for (col_idx, col) in (bounds.0.x..bounds.1.x).enumerate() {
+                let dest_idx = row * WIDTH as i32 + col;
+                let source_idx = row_idx * stride + col_idx;
+                let pixel = unsafe { source.add(source_idx).read() };
+                self.buffer[dest_idx as usize] = pixel;
+            }
+        }
+    }
+
     pub fn draw_header(&mut self) {
         self.state.fg_color = HEADER_COLOR;
         self.fill_rect(Rect::HEADER_CLIP);
@@ -247,8 +268,8 @@ pub struct Rect(pub Point, pub Point);
 
 impl Rect {
     pub const FULL_CLIP: Self = Rect::new(0, 0, WIDTH as i32, HEIGHT as i32);
-    pub const USER_CLIP: Self = Rect::new(0, HEADER_HEIGHT as i32, WIDTH as i32, HEIGHT as i32);
-    pub const HEADER_CLIP: Self = Rect::new(0, 0, WIDTH as i32, HEADER_HEIGHT as i32);
+    pub const USER_CLIP: Self = Rect::new(0, HEADER_HEIGHT, WIDTH as i32, HEIGHT as i32);
+    pub const HEADER_CLIP: Self = Rect::new(0, 0, WIDTH as i32, HEADER_HEIGHT);
 
     pub const fn new(mut x0: i32, mut y0: i32, mut x1: i32, mut y1: i32) -> Self {
         if x0 > x1 {