Merge pull request kotetuco#4 from kotetuco/feature/fill_graphic

図形描画処理を実装。

Author: kotetuco

src/gba_color.rs

@@ -0,0 +1,15 @@
+//
+// kotetuco, 2017
+//
+
+use rgb::RGB;
+
+pub trait GBAColor {
+    fn convert_u16_color(&self) -> u16;
+}
+
+impl GBAColor for RGB {
+    fn convert_u16_color(&self) -> u16{
+        return (((self.b >> 3) as u16) << 10) + (((self.g >> 3) as u16) << 5) + (self.r >> 3) as u16;
+    }
+}

src/graphics.rs

@@ -0,0 +1,80 @@
+//
+// kotetuco, 2017
+//
+
+use rgb::RGB;
+use gba_color::GBAColor;
+
+pub struct Graphics {
+    vram_address: u32,
+    screen_x: u16,
+    screen_y: u16,
+}
+
+impl Graphics {
+    pub fn new() -> Self {
+        Graphics {
+            vram_address: 0x06000000,
+            screen_x: 240,
+            screen_y: 160,
+        }
+    }
+
+    pub fn draw_dot(&self, x:u16, y:u16, color:&RGB) {
+        let offset: u32 = ((y * self.screen_x) + x) as u32;
+        let vram: *mut u16 = (self.vram_address + (offset * 2)) as *mut u16;
+        unsafe {
+            *vram = color.convert_u16_color();
+        }
+    }
+
+    pub fn draw_box(&self, x:u16, y:u16, width:u16, height:u16, color:&RGB) {
+        for offset_y in 0..height {
+            for offset_x in 0..width {
+                let valid_x = if x + offset_x > self.screen_x { self.screen_x } else { x + offset_x };
+                let valid_y = if y + offset_y > self.screen_y { self.screen_y } else { y + offset_y };
+                self.draw_dot(valid_x, valid_y, color);
+            }
+        }
+    }
+
+    #[no_mangle]
+    pub fn draw_circle(&self, center_x:u16, center_y:u16, r:u16, color:&RGB) {
+        let mut x: u16 = r;
+        let mut y: u16 = 0;
+        let mut f: i32 = 3 - ((r as i32) * 2);
+
+        // draw center
+        self.draw_dot(center_x, center_y, color);
+
+        loop {
+            if x < y {
+                break;
+            }
+
+            self.draw_dot(center_x + x, center_y + y, color);
+            self.draw_dot(center_x - x, center_y + y, color);
+            self.draw_dot(center_x + x, center_y - y, color);
+            self.draw_dot(center_x - x, center_y - y, color);
+            self.draw_dot(center_x + y, center_y + x, color);
+            self.draw_dot(center_x - y, center_y + x, color);
+            self.draw_dot(center_x + y, center_y - x, color);
+            self.draw_dot(center_x - y, center_y - x, color);
+
+            if f >= 0 {
+                x -= 1;
+                f -= (x * 4) as i32;
+            }
+            y += 1;
+            f += (4 * y + 2) as i32;
+        }
+    }
+
+    pub fn width(&self) -> u16 {
+        return self.screen_x;
+    }
+
+    pub fn height(&self) -> u16 {
+        return self.screen_y;
+    }
+}

src/lib.rs

@@ -1,6 +1,6 @@
 //
 // kotetuco, 2017
-// 
+//
 
 #![feature(lang_items)]
 #![no_std]
@@ -10,22 +10,23 @@
 extern crate compiler_builtins;
 extern crate rlibc;
 
+mod rgb;
+mod gba_color;
+mod graphics;
+
+use rgb::RGB;
+use rgb::RGBDef;
+use graphics::Graphics;
+
 #[no_mangle]
 pub extern "C" fn entry() {
     init_graphic();
 
-    let color:u16 = convert_u16_color(0, 255, 0);
-    let vram_address:u32 = 0x06000000;
-
-    for y in 0..160 {
-        for x in 0..240 {
-            let offset: u32 = ((y * 240) + x) as u32;
-            let vram: *mut u16 = (vram_address + (offset * 2)) as *mut u16;
-            unsafe {
-                *vram = color;
-            }
-        }
-    }
+    let graphics: Graphics = Graphics::new();
+    graphics.draw_box(20, 20, 100, 100, &RGB::light_red());
+    graphics.draw_box(70, 50, 100, 100, &RGB::light_green());
+    graphics.draw_box(120, 80, 100, 100, &RGB::light_blue());
+    graphics.draw_circle(25, 25, 20, &RGB::light_yellow());
 
     loop {}
 }
@@ -40,10 +41,6 @@ fn init_graphic() {
     }
 }
 
-fn convert_u16_color(r:u8, g:u8, b:u8) -> u16{
-    return (((b >> 3) as u16) << 10) + (((g >> 3) as u16) << 5) + (r >> 3) as u16;
-}
-
 #[allow(private_no_mangle_fns)]
 #[no_mangle]
 #[lang = "panic_fmt"]
@@ -53,5 +50,3 @@ extern "C" fn panic_fmt() -> ! {
 
 #[lang = "eh_personality"]
 pub extern fn eh_personality() {}
-
-

src/rgb.rs

@@ -0,0 +1,94 @@
+//
+// kotetuco, 2017
+//
+
+pub struct RGB {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
+}
+
+pub trait RGBDef {
+    fn black() -> Self;
+    fn light_red() -> Self;
+    fn light_green() -> Self;
+    fn light_yellow() -> Self;
+    fn light_blue() -> Self;
+    fn light_purple() -> Self;
+    fn light_pale_blue() -> Self;
+    fn white() -> Self;
+    fn light_gray() -> Self;
+    fn dark_red() -> Self;
+    fn dark_green() -> Self;
+    fn dark_yellow() -> Self;
+    fn dark_blue() -> Self;
+    fn dark_purple() -> Self;
+    fn dark_pale_blue() -> Self;
+    fn dark_gray() -> Self;
+}
+
+impl RGBDef for RGB {
+    fn black() -> RGB {
+        return RGB { r: 0x00, g: 0x00, b: 0x00,};
+    }
+
+    fn light_red() -> RGB {
+        return RGB { r: 0xff, g: 0x00, b: 0x00,};
+    }
+
+    fn light_green() -> RGB {
+        return RGB { r: 0x00, g: 0xff, b: 0x00,};
+    }
+
+    fn light_yellow() -> RGB {
+        return RGB { r: 0xff, g: 0xff, b: 0x00,};
+    }
+
+    fn light_blue() -> RGB {
+        return RGB { r: 0x00, g: 0x00, b: 0xff,};
+    }
+
+    fn light_purple() -> RGB {
+        return RGB { r: 0xff, g: 0x00, b: 0xff,};
+    }
+
+    fn light_pale_blue() -> RGB {
+        return RGB { r: 0x00, g: 0xff, b: 0xff,};
+    }
+
+    fn white() -> RGB {
+        return RGB { r: 0xff, g: 0xff, b: 0xff,};
+    }
+
+    fn light_gray() -> RGB {
+        return RGB { r: 0xc6, g: 0xc6, b: 0xc6,};
+    }
+
+    fn dark_red() -> RGB {
+        return RGB { r: 0x84, g: 0x00, b: 0x00,};
+    }
+
+    fn dark_green() -> RGB {
+        return RGB { r: 0x00, g: 0x84, b: 0x00,};
+    }
+
+    fn dark_yellow() -> RGB {
+        return RGB { r: 0x84, g: 0x84, b: 0x00,};
+    }
+
+    fn dark_blue() -> RGB {
+        return RGB { r: 0x00, g: 0x00, b: 0x84,};
+    }
+
+    fn dark_purple() -> RGB {
+        return RGB { r: 0x84, g: 0x00, b: 0x84,};
+    }
+
+    fn dark_pale_blue() -> RGB {
+        return RGB { r: 0x00, g: 0x84, b: 0x84,};
+    }
+
+    fn dark_gray() -> RGB {
+        return RGB { r: 0x84, g: 0x84, b: 0x84,};
+    }
+}