150 lines
3.2 KiB
Rust
150 lines
3.2 KiB
Rust
use crate::{
|
|
processor::{memory::mmio::gpu::Colour, Direction},
|
|
VERBOSE,
|
|
};
|
|
use std::{io, mem::transmute};
|
|
|
|
#[macro_export]
|
|
macro_rules! verbose_println {
|
|
($($tts:tt)*) => {
|
|
if $crate::util::is_verbose() {
|
|
println!($($tts)*);
|
|
}
|
|
};
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! verbose_print {
|
|
($($tts:tt)*) => {
|
|
if $crate::util::is_verbose() {
|
|
print!($($tts)*);
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) fn pause() -> String {
|
|
let mut line = String::new();
|
|
match io::stdin().read_line(&mut line) {
|
|
Ok(_) => line,
|
|
Err(_) => String::from(""),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_verbose() -> bool {
|
|
match VERBOSE.get() {
|
|
Some(v) => *v,
|
|
None => false,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn as_signed(unsigned: u8) -> i8 {
|
|
unsafe { transmute(unsigned) }
|
|
}
|
|
|
|
pub(crate) fn get_bit(byte: u8, flag: u8) -> bool {
|
|
let mask = 1 << flag;
|
|
let got = byte & mask;
|
|
got > 0x0
|
|
}
|
|
|
|
pub(crate) fn set_or_clear_bit(byte: u8, flag: u8, condition: bool) -> u8 {
|
|
if condition {
|
|
set_bit(byte, flag)
|
|
} else {
|
|
clear_bit(byte, flag)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_bit(byte: u8, flag: u8) -> u8 {
|
|
byte | (1 << flag)
|
|
}
|
|
|
|
pub(crate) fn clear_bit(byte: u8, flag: u8) -> u8 {
|
|
byte & (!(1 << flag))
|
|
}
|
|
|
|
pub(crate) fn rotate(byte: u8, direction: &Direction) -> (u8, bool) {
|
|
match direction {
|
|
Direction::Left => {
|
|
let carry = get_bit(byte, 7);
|
|
let r = byte << 1;
|
|
(r, carry)
|
|
}
|
|
Direction::Right => {
|
|
let carry = get_bit(byte, 0);
|
|
let r = byte >> 1;
|
|
(r, carry)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_rotation_carry(direction: &Direction) -> u8 {
|
|
match direction {
|
|
Direction::Left => 0b1,
|
|
Direction::Right => 0b10000000,
|
|
}
|
|
}
|
|
|
|
pub trait Nibbles {
|
|
fn get_low_nibble(&self) -> u8;
|
|
fn get_high_nibble(&self) -> u8;
|
|
fn set_low_nibble(&mut self, val: u8);
|
|
fn set_high_nibble(&mut self, val: u8);
|
|
}
|
|
|
|
impl Nibbles for u8 {
|
|
fn get_low_nibble(&self) -> u8 {
|
|
*self & 0x0F
|
|
}
|
|
|
|
fn get_high_nibble(&self) -> u8 {
|
|
(*self >> 4) & 0x0F
|
|
}
|
|
|
|
fn set_low_nibble(&mut self, val: u8) {
|
|
*self = (*self & 0xF0) | (val & 0x0F);
|
|
}
|
|
|
|
fn set_high_nibble(&mut self, val: u8) {
|
|
*self = (*self & 0x0F) | (val << 4);
|
|
}
|
|
}
|
|
|
|
pub fn scale_buffer<T: From<Colour> + Copy>(
|
|
buffer: &[T],
|
|
width: usize,
|
|
height: usize,
|
|
factor: usize,
|
|
) -> Vec<T> {
|
|
let mut v = vec![];
|
|
for y in 0..height {
|
|
for _ in 0..factor {
|
|
for x in 0..width {
|
|
for _ in 0..factor {
|
|
v.push(buffer[(y * width) + x]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
v
|
|
}
|
|
|
|
pub fn scale_buffer_in_place<T: From<Colour> + Copy>(
|
|
buffer: &[T],
|
|
target: &mut [T],
|
|
width: usize,
|
|
height: usize,
|
|
factor: usize,
|
|
) {
|
|
for y in 0..height {
|
|
for y_2 in 0..factor {
|
|
for x in 0..width {
|
|
for x_2 in 0..factor {
|
|
target[(((y * factor) + y_2) * (width * factor)) + (x * factor) + x_2] =
|
|
buffer[(y * width) + x];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|