Mandelrust

Author: MarcNumworks

.cargo/config

@@ -1,5 +1,5 @@
 [target.thumbv7em-none-eabihf]
-runner = 'npx --yes -- [email protected].15 install-nwa'
+runner = 'npx --yes -- [email protected].16 install-nwa'
 rustflags = ["-C", "link-arg=--relocatable", "-C", "link-arg=-no-gc-sections"]
 
 [build]

src/eadk.rs

@@ -1,4 +1,5 @@
 #[repr(C)]
+#[derive(Clone,Copy)]
 pub struct Color {
     pub rgb565: u16
 }
@@ -95,6 +96,76 @@ extern "C" {
     fn eadk_random() -> u32;
 }
 
+pub mod keyboard {
+    pub struct Scan {
+        value: u64
+    }
+
+    impl Scan {
+        pub fn scan() -> Scan {
+            unsafe {
+                Scan { value: eadk_keyboard_scan() }
+            }
+        }
+
+        pub fn is_key_down(&self, key: Key) -> bool {
+            (self.value & (1 << key as u8)) != 0
+        }
+    }
+
+    pub enum Key {
+        Left  =  0,
+        Up  =  1,
+        Down = 2,
+        Right = 3,
+        Ok = 4,
+        Back = 5,
+        Home  =  6,
+        Shift = 12,
+        Alpha = 13,
+        Xnt = 14,
+        Bar = 15,
+        Toolbox = 16,
+        Backspace = 17,
+        Exp = 18,
+        Ln = 19,
+        Log = 20,
+        Imaginary = 21,
+        Comma = 22,
+        Power = 23,
+        Sine = 24,
+        Cosine = 25,
+        Tangent = 26,
+        Pi = 27,
+        Sqrt = 28,
+        Square = 29,
+        Seven = 30,
+        Eight = 31,
+        Nine = 32,
+        LeftParenthesis = 33,
+        RightParenthesis = 34,
+        Four = 36,
+        Five = 37,
+        Six = 38,
+        Multiplication = 39,
+        Division = 40,
+        One = 42,
+        Two = 43,
+        Three = 44,
+        Plus = 45,
+        Minus = 46,
+        Zero = 48,
+        Dot = 49,
+        EE = 50,
+        Ans = 51,
+        Exe = 52,
+    }
+
+    extern "C" {
+        fn eadk_keyboard_scan() -> u64;
+    }
+}
+
 use core::panic::PanicInfo;
 
 #[panic_handler]

src/icon.png

@@ -2,33 +2,191 @@
 #![no_main]
 
 pub mod eadk;
+use eadk::*;
+
+use core::ops::Range;
+
+#[allow(non_upper_case_globals)]
 
 #[used]
 #[link_section = ".rodata.eadk_app_name"]
-pub static EADK_APP_NAME: [u8; 10] = *b"HelloRust\0";
+pub static EADK_APP_NAME: [u8; 11] = *b"Mandelrust\0";
 
 #[used]
 #[link_section = ".rodata.eadk_api_level"]
 pub static EADK_APP_API_LEVEL: u32 = 0;
 
 #[used]
 #[link_section = ".rodata.eadk_app_icon"]
-pub static EADK_APP_ICON: [u8; 4250] = *include_bytes!("../target/icon.nwi");
+pub static EADK_APP_ICON: [u8; 2648] = *include_bytes!("../target/icon.nwi");
+
+const WIDTH: usize = 320;
+const HEIGHT: usize = 240;
+
+fn color_range(n : u8) -> Color {
+    let n = n as u16;
+    let r = (n/2)<<11;
+    let g = (0xb7*n/0xff)<<5;
+    let b = (0x34*n/0xff)>>1;
+    Color { rgb565: r | g | b }
+}
+
+const BHEIGHT : usize = 256;
 
-fn random_u16() -> u16 {
-    return eadk::random() as u16;
+struct Buffer {
+    // 5 values of 6 bits per word
+    buffer : [[u8; BHEIGHT]; WIDTH],
+    dx : usize,
+    dy : usize,
 }
 
-fn random_coordinate() -> u16 {
-    return (eadk::random() % 0xFF) as u16;
+impl Buffer {
+    fn new() -> Buffer {
+        Buffer { buffer: [[0; BHEIGHT]; WIDTH], dx: 0, dy: 0 }
+    }
+
+    fn pos(&self, x: usize, y: usize) -> (usize, usize) {
+        ((x + self.dx)%WIDTH, (y + self.dy)%BHEIGHT)
+    }
+
+    fn set(&mut self, x: usize, y:usize, v:u8) {
+        let (xa, ya) = self.pos(x,y);
+        self.buffer[xa][ya] = v;
+    }
+
+    fn get(&self, x: usize, y: usize) -> u8 {
+        let (xa, ya) = self.pos(x,y);
+        self.buffer[xa][ya]
+    }
+
+    fn scroll_x(&mut self, delta_x: isize) {
+        self.dx = (((self.dx as isize) + delta_x + WIDTH as isize) as usize) % WIDTH;
+    }
+
+    fn scroll_y(&mut self, delta_y: isize) {
+        self.dy = (((self.dy as isize) + delta_y + BHEIGHT as isize) as usize) % BHEIGHT;
+    }
+}
+
+struct Zone {
+    x_range: Range<usize>,
+    y_range: Range<usize>,
+}
+
+impl Zone {
+    fn screen() -> Zone {
+        Zone { x_range: 0..WIDTH, y_range: 0..HEIGHT }
+    }
+}
+
+fn mandel(buf: &mut Buffer, zone: Zone, x_center: f32, y_center: f32, width:f32, n:u8, coarse: bool) {
+    let scale : f32 = width / WIDTH as f32;
+
+    for xi in zone.x_range {
+        if coarse && xi%3 != 1 { continue }
+        let cr : f32 = ((xi as i16 - (WIDTH/2) as i16) as f32)*scale+x_center;
+        for yi in zone.y_range.clone() {
+            if coarse && yi%3 != 1 { continue }
+            let ci : f32 = ((yi as i16 - (HEIGHT/2) as i16) as f32)*scale+y_center;
+            let mut zr : f32 = 0.;
+            let mut zi : f32 = 0.;
+            let mut v = 63;
+            for n in 0..n {
+                let ozr = zr;
+                zr = zr*zr - zi*zi + cr;
+                zi = 2.*ozr*zi + ci;
+                if zr*zr + zi*zi > 4. {
+                    v = n;
+                    break;
+                }
+            }
+            if coarse {
+                for x in xi-1..=xi+1 {
+                    for y in yi-1..=yi+1 {
+                        buf.set(x, y, v);
+                    }
+                }
+            } else {
+                buf.set(xi, yi, v);
+            }
+        }
+    }
+}
+
+fn blit(buf: &Buffer) {
+    display::wait_for_vblank();
+    const SIDE: usize = 16;
+    let mut array = [Color { rgb565: 0 }; SIDE*SIDE];
+    for x in 0..WIDTH/SIDE {
+        for y in 0..HEIGHT/SIDE {
+            for xi in 0..SIDE {
+                for yi in 0..SIDE {
+                    array[yi*SIDE+xi] = color_range(buf.get(x*SIDE+xi,y*SIDE+yi));
+                }
+            }
+            let r = Rect { x: (SIDE*x) as u16, y: (SIDE*y) as u16, width: SIDE
+    as u16, height: SIDE as u16};
+            display::push_rect(r, &array);
+        }
+    }
 }
 
 #[no_mangle]
-pub fn main() {
-    for _ in 0..100 {
-        let c = eadk::Color { rgb565: random_u16() };
-        let r = eadk::Rect { x: random_coordinate(), y: random_coordinate(), width: random_coordinate(), height: random_coordinate() };
-        eadk::display::push_rect_uniform(r, c);
+fn main() {
+    let mut buffer = Buffer::new();
+    let mut x : f32 = -0.5;
+    let mut y : f32 = 0.0;
+    let mut n : u8 = 64;
+    let mut size : f32 = 3.5;
+    let mut was_coarse : bool = false;
+    let delta_pixel : isize = 2;
+    mandel(&mut buffer, Zone::screen(), x, y, size, n, false);
+    blit(&buffer);
+    loop {
+        let scan = keyboard::Scan::scan();
+        let mut zone = Zone::screen();
+        use keyboard::Key::*;
+        let factor = if scan.is_key_down(Shift) { 5 } else { 1 };
+        let delta_pixel = factor * delta_pixel;
+        let delta_size = delta_pixel as f32 * size / WIDTH as f32;
+        let mut coarse = false;
+        if scan.is_key_down(Plus) || scan.is_key_down(Ok) {
+            size /= 1.5;
+            coarse = true;
+            was_coarse = true;
+        } else if scan.is_key_down(Minus) || scan.is_key_down(Back) {
+            size *= 1.5;
+            coarse = true;
+            was_coarse = true;
+        } else if scan.is_key_down(Multiplication) {
+            n = (n + 4).clamp(1,63);
+        } else if scan.is_key_down(Division) {
+            n = (n - 4).clamp(1,100);
+        } else if scan.is_key_down(Left) {
+            x -= delta_size;
+            buffer.scroll_x(-delta_pixel);
+            zone.x_range = 0..(delta_pixel as usize);
+        } else if scan.is_key_down(Right) {
+            x += delta_size;
+            buffer.scroll_x(delta_pixel);
+            zone.x_range= (WIDTH - delta_pixel as usize)..WIDTH;
+        } else if scan.is_key_down(Up) {
+            y -= delta_size;
+            buffer.scroll_y(-delta_pixel);
+            zone.y_range = 0..(delta_pixel as usize);
+        } else if scan.is_key_down(Down) {
+            y += delta_size;
+            buffer.scroll_y(delta_pixel);
+            zone.y_range = (HEIGHT - delta_pixel as usize)..HEIGHT;
+        } else if scan.is_key_down(Zero) {
+            x = -0.5; y = 0.0; size = 3.5; n = 40;
+        } else if was_coarse {
+            was_coarse = false;
+        } else {
+            continue;
+        }
+        size = size.min(3.5);
+        mandel(&mut buffer,zone,x,y,size,n,coarse);
+        blit(&buffer);
     }
-    loop {}
 }