[draw] Add draw calls

src/device/device.rs

@@ -60,8 +60,13 @@ impl Device {
         let pc = self.registers.pc as usize;
         let instr_slice = self.memory.get(pc..pc + 2).expect("Failed to get memory");
         self.registers.pc += 2;
+
         let instruction = Instruction::decode_instruction(instr_slice);
         self.execute_instruction(instruction);
+
+    }
+    pub fn get_framebuffer_index(x:usize,y:usize)->usize{
+        y*Self::FRAME_BUFFER_WIDTH + x
     }
     pub fn execute_instruction(&mut self, instruction: Instruction) {
         // thread::sleep(Duration::from_millis(250));
@@ -71,6 +76,10 @@ impl Device {
                 log::info!("Executing passthrough");
             }
             Instruction::ClearScreen => {
+                let mut frame_buffer = self.frame_buffer.lock().expect("Failed to grab framebuffer for drawing");
+                for pixel in frame_buffer.iter_mut(){
+                    *pixel = 0;
+                }
                 log::info!("ClearScreen")
             }
             Instruction::JumpTo(new_pc) => {
@@ -83,10 +92,31 @@ impl Device {
                 self.registers.v[reg_location] += value;
             }
             Instruction::SetIndex(value) => {
+                log::info!("Setting index to {}",value);
                 self.registers.i = value;
             }
-            Instruction::Draw(x, y, n) => {
-                let frame_buffer = self.frame_buffer.lock();
+            Instruction::Draw(regx,regy, n) => {
+                let mut frame_buffer = self.frame_buffer.lock().expect("Failed to grab framebuffer for drawing");
+                let x = self.registers.v[regx] as usize;
+                let y = self.registers.v[regy] as usize;
+
+                for i in 0..n as usize{
+                    let index = Self::get_framebuffer_index(x,y+i);
+                    let slice_from_memory = self.memory[self.registers.i as usize];
+
+                    for bit_index in (0..8).rev() {
+                        // if i'm going to the next line, stop
+                        if Self::get_framebuffer_index(0, y+1)==index {
+                            break;
+                        }
+                        let bit = (slice_from_memory & 1<<bit_index) >> bit_index;
+
+
+                        frame_buffer[index+(7-bit_index)] = frame_buffer[index+(7-bit_index)] ^ (bit * 0xff);
+                    }
+                }
+                // TODO fix carry bit
+                log::info!("Drawing at ({},{}) for {} pixels from {}",x,y,n,self.registers.i);
                 log::warn!("Draw call unimplemented");
             }
         };

src/main.rs

@@ -1,6 +1,6 @@
 use std::fs::File;
 use std::io::Read;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, MutexGuard};
 use std::thread;
 use std::time::Duration;
 use log::LevelFilter;
@@ -8,8 +8,8 @@ use sdl2::audio::{AudioQueue, AudioSpecDesired};
 use sdl2::event::Event;
 use sdl2::EventPump;
 use sdl2::keyboard::Keycode;
-use sdl2::pixels::Color;
-use sdl2::render::{BlendMode, WindowCanvas};
+use sdl2::pixels::{Color, PixelFormatEnum};
+use sdl2::render::{BlendMode, TextureAccess, WindowCanvas};
 use simple_logger::SimpleLogger;
 use device::timer::Timer;
 use crate::device::Device;
@@ -51,7 +51,8 @@ fn main() {
         }
     });
 
-    let (mut canvas, mut event_pump) = initiate_sdl(2f32);
+    let (mut canvas, mut event_pump) = initiate_sdl(8f32);
+    let mut fb_sdl = vec![0;3*Device::FRAME_BUFFER_SIZE];
 
     canvas.set_draw_color(Color::BLACK);
     canvas.clear();
@@ -81,7 +82,8 @@ fn main() {
         // The rest of the game loop goes here...
         {
             let lock =  frame_buffer_for_display.lock().expect("Failed to get Display");
-            log::info!("Framebuffer status: {:?}",lock);
+            draw_screen(lock,&mut canvas,&mut fb_sdl);
+            // log::info!("Framebuffer status: {:?}",lock);
         }
         canvas.present();
 
@@ -95,6 +97,22 @@ fn main() {
 
 }
 
+fn draw_screen(frame_buffer: MutexGuard<Box<[u8; 2048]>>, window_canvas: &mut WindowCanvas, x1: &mut Vec<u8>) {
+    for (i,pixel) in frame_buffer.iter().enumerate(){
+        x1[3*i] = *pixel;
+        x1[3*i+1] = *pixel;
+        x1[3*i+2] = *pixel;
+    }
+    drop(frame_buffer);
+
+    let tex_creator = window_canvas.texture_creator();
+    let mut tex = tex_creator.create_texture(PixelFormatEnum::RGB24, TextureAccess::Streaming, Device::FRAME_BUFFER_WIDTH as u32, Device::FRAME_BUFFER_HEIGHT as u32).expect("Failed to create tex");
+    tex.with_lock(None,|u,i|{
+        u.copy_from_slice(x1);
+    }).expect("Unwrap tex");
+    window_canvas.copy(&tex,None,None);
+}
+
 fn get_frame_buffer() -> Arc<Mutex<Box<[u8; 2048]>>> {
     Arc::new(Mutex::new(vec![0u8; Device::FRAME_BUFFER_SIZE].into_boxed_slice().try_into().unwrap()))
 }