librsmsx 0.5.2

a MSX emulator written in rust, a port from gomsx
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use arg::Args;
use log::{Level, LevelFilter, Metadata, Record};
use sdl3::{event::Event, keyboard::Keycode};
use std::{cell::RefCell, fs, rc::Rc, time::Duration};

use librsmsx::{libs::msx::SaveData, prelude::*};

#[derive(Args, Debug)]
struct MyArgs {
    #[arg(long)]
    ///game dump
    dump: String,

    #[arg(long, default_value = "true")]
    ///Best quality rendering
    quality: bool,
}

static MY_LOGGER: MyLogger = MyLogger;

struct MyLogger;

impl log::Log for MyLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Debug
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            println!("{} - {}", record.level(), record.args());
        }
        // die on error
        if record.metadata().level() == Level::Error {
            panic!();
        }
    }
    fn flush(&self) {}
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    log::set_logger(&MY_LOGGER).unwrap();
    log::set_max_level(LevelFilter::Debug);

    let args: std::vec::Vec<_> = std::env::args().skip(1).collect();
    match MyArgs::from_args(args.iter().map(|x| x.as_str())) {
        Ok(args) => {
            let base_scale = 2.0;
            let scale_magnifier = 2.0;
            let mut sys = BaseSystem::new(base_scale * scale_magnifier);
            let vdp = Rc::new(RefCell::new(Vdp::new(GraphicsType::Normal, args.quality)));
            let mut event_pump = sys.create_event_pump();
            let contents = fs::read(args.dump).unwrap();
            let dd: SaveData = serde_json::from_slice(&contents).unwrap();
            vdp.borrow_mut().set_data(dd.vdp);
            vdp.borrow_mut().update_buffer();
            {
                let scale = sys.get_scale();
                let canvas = sys.get_canvas();
                canvas.set_scale(scale, scale).unwrap();
            }

            'running: loop {
                for event in event_pump.poll_iter() {
                    match event {
                        Event::Quit { .. }
                        | Event::KeyDown {
                            keycode: Some(Keycode::Escape),
                            ..
                        } => break 'running,
                        _ => {}
                    }
                }
                vdp.borrow_mut().graphics_render(&mut sys);
                let canvas = sys.get_canvas();
                canvas.present();
                std::thread::sleep(Duration::from_millis(10_u64));
            }
        }
        Err(err) => println!("err={:?}", err),
    }
    Ok(())
}