bauer/jane
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

messing around with glyphbrush

Browse Source
This commit is contained in:
Daniel Bauer
2019-12-26 11:58:12 +01:00
parent 149df4ee35
commit e57d400d16
5 changed files with 374 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

461
src/main.rs
View File

@@ -4,7 +4,8 @@ extern crate simple_logger;
extern crate phf;
extern crate piston_window;
mod nes;
mod nes;
mod render;
use std::path::Path;
use piston_window::*;
@@ -16,6 +17,11 @@ use nes::disasm::*;
use opengl_graphics::OpenGL;
use log::Level;
use piston_window::Text;
use render::*;
use gfx_glyph::{Section, GlyphBrushBuilder,GlyphBrush};
use gfx_device_gl::{Factory,Resources};
// font options
const FT_SIZE_PT: u32 = 6;
@@ -25,14 +31,8 @@ const FT_COLOR_RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
const FT_COLOR_GREEN: [f32; 4] = [0.0, 1.0, 0.0, 1.0];
const FT_LINE_DISTANCE: f64 = FT_SIZE_PX * 0.5;
// font for text drawing
fn get_glyphs(window: &mut PistonWindow) -> Glyphs {
let font_path = Path::new("resources/fonts/PressStart2P.ttf");
window.load_font(font_path).unwrap()
}
fn main() {
simple_logger::init_with_level(Level::Debug).unwrap();
simple_logger::init_with_level(Level::Error).unwrap();
let mut bus = MemoryBus::new();
let cartridge = Path::new("test_roms/registers.nes");
@@ -71,250 +71,283 @@ fn main() {
.exit_on_esc(true).graphics_api(OpenGL::V3_2).build().unwrap();
let mut event_settings = EventSettings::new();
event_settings.max_fps = 60;
event_settings.ups = 107400;
let mut events = Events::new(event_settings);
let mut glyphs = get_glyphs(&mut window);
let ft: &[u8] = include_bytes!("../resources/fonts/PressStart2P.ttf");
let mut glyphs = GlyphBrushBuilder::using_font_bytes(ft)
.initial_cache_size((256, 256))
.build(window.factory.clone());
let mut cpu_renderer = CPURenderer::new(&cpu);
// Main loop
let mut run = false;
while let Some(event) = events.next(&mut window) {
if let Some(_) = event.render_args() {
render(&mut window, &event, &mut glyphs, &cpu, &bus, &disasm);
cpu_renderer.update(&cpu);
render(&mut window, &event, &mut glyphs, &mut cpu_renderer, &bus, &disasm);
}
if let Some(_) = event.update_args() {
if run {
cpu.clock(&mut bus);
// while cpu.is_ahead() {
// cpu.clock(&mut bus);
// }
}
}
if let Some(Button::Keyboard(key)) = event.press_args() {
match key {
Key::C => cpu.clock(&mut bus), // advance one clock
Key::Space => { // advance to next instruction
Key::S => { // advance to next instruction
cpu.clock(&mut bus);
while cpu.is_ahead() {
cpu.clock(&mut bus);
}
}
Key::R => cpu.reset(&mut bus),
Key::Space => run = !run,
Key::Up => {
event_settings.ups = (event_settings.ups as f64 * 1.1) as u64 + 1;
events = Events::new(event_settings);
debug!("UPS: {}", event_settings.ups);
}
Key::Down => {
event_settings.ups = (event_settings.ups as f64 * 0.91) as u64;
events = Events::new(event_settings);
debug!("UPS: {}", event_settings.ups);
}
_ => { }
}
}
}
}
}
fn render(window: &mut PistonWindow, event: &Event, glyphs: &mut Glyphs, cpu: &CPU, bus: &MemoryBus, disasm: &Disasm) {
fn render(window: &mut PistonWindow, event: &Event,
glyphs: &mut GlyphBrush<Resources, Factory>,
cpu_renderer: &mut CPURenderer, bus: &MemoryBus, disasm: &Disasm) {
window.draw_2d(event, |c, g, d| {
clear([0.0, 0.0, 1.0, 1.0], g);
let debug_offset = [10.0, 10.0];
render_cpu(&c, g, glyphs, cpu, debug_offset);
render_disasm(&c, g, glyphs, disasm, cpu.regs.pc,
[debug_offset[0], debug_offset[1] + (7.0 * (FT_LINE_DISTANCE+FT_SIZE_PX))]);
render_memory(&c, g, glyphs, bus,
[debug_offset[0] + 300.0, debug_offset[1]]);
// let debug_offset = [10.0, 10.0];
// render_cpu(&c, g, glyphs, cpu, debug_offset);
// render_disasm(&c, g, glyphs, disasm, cpu.regs.pc,
// [debug_offset[0], debug_offset[1] + (7.0 * (FT_LINE_DISTANCE+FT_SIZE_PX))]);
// render_memory(&c, g, glyphs, bus,
// [debug_offset[0] + 300.0, debug_offset[1]]);
glyphs.factory.encoder.flush(d);
// glyphs.factory.encoder.flush(d);
});
cpu_renderer.draw(glyphs);
glyphs.use_queue().draw(&mut window.encoder, &window.output_color);
window.encoder.flush(&mut window.device);
}
fn render_cpu(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, cpu: &CPU, offset: [f64; 2]) {
let mut transform = c.transform
.trans(offset[0], offset[1] + FT_SIZE_PX);
let text_white = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
let text_on = Text::new_color(FT_COLOR_GREEN, FT_SIZE_PT);
let text_off = Text::new_color(FT_COLOR_RED, FT_SIZE_PT);
// fn render_cpu(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, cpu: &CPU, offset: [f64; 2]) {
// let mut transform = c.transform
// .trans(offset[0], offset[1] + FT_SIZE_PX);
// let text_white = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
// let text_on = Text::new_color(FT_COLOR_GREEN, FT_SIZE_PT);
// let text_off = Text::new_color(FT_COLOR_RED, FT_SIZE_PT);
let mut text = text_white;
text.draw(
&"Flags:",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
// let mut text = text_white;
// text.draw(
// &"Flags:",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
transform = transform.trans(70.0, 0.0);
text = if cpu.get_flag(NEGATIVE) == 1 { text_on } else { text_off };
text.draw(
&"N",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(OVERFLOW) == 1 { text_on } else { text_off };
text.draw(
&"V",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text_white.draw(
&"-",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(BREAK) == 1 { text_on } else { text_off };
text.draw(
&"B",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(DECIMAL) == 1 { text_on } else { text_off };
text.draw(
&"D",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(IRQ) == 1 { text_on } else { text_off };
text.draw(
&"I",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(ZERO) == 1 { text_on } else { text_off };
text.draw(
&"Z",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text = if cpu.get_flag(CARRY) == 1 { text_on } else { text_off };
text.draw(
&"C",
glyphs,
&c.draw_state,
transform,
g
).unwrap();
transform = transform.trans(16.0, 0.0);
text_white.draw(
&format!("({:#4x})", cpu.regs.flags),
glyphs,
&c.draw_state,
transform,
g
).unwrap();
// transform = transform.trans(70.0, 0.0);
// text = if cpu.get_flag(NEGATIVE) == 1 { text_on } else { text_off };
// text.draw(
// &"N",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(OVERFLOW) == 1 { text_on } else { text_off };
// text.draw(
// &"V",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text_white.draw(
// &"-",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(BREAK) == 1 { text_on } else { text_off };
// text.draw(
// &"B",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(DECIMAL) == 1 { text_on } else { text_off };
// text.draw(
// &"D",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(IRQ) == 1 { text_on } else { text_off };
// text.draw(
// &"I",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(ZERO) == 1 { text_on } else { text_off };
// text.draw(
// &"Z",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text = if cpu.get_flag(CARRY) == 1 { text_on } else { text_off };
// text.draw(
// &"C",
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// transform = transform.trans(16.0, 0.0);
// text_white.draw(
// &format!("({:#4x})", cpu.regs.flags),
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
let cpu_register_texts = [
&format!("A: {0:#x} ({0})", cpu.regs.a),
&format!("X: {0:#x} ({0})", cpu.regs.x),
&format!("Y: {0:#x} ({0})", cpu.regs.y),
&format!("Stack P: {0:#x} ({0})", cpu.regs.sp),
&format!("Program P: {:#x}", cpu.regs.pc),
];
// let cpu_register_texts = [
// &format!("A: {0:#x} ({0})", cpu.regs.a),
// &format!("X: {0:#x} ({0})", cpu.regs.x),
// &format!("Y: {0:#x} ({0})", cpu.regs.y),
// &format!("Stack P: {0:#x} ({0})", cpu.regs.sp),
// &format!("Program P: {:#x}", cpu.regs.pc),
// ];
for (i, &text) in cpu_register_texts.iter().enumerate() {
let y_offset = (i+2) as f64 * (FT_LINE_DISTANCE + FT_SIZE_PX);
let transform = c.transform.trans(offset[0], offset[1] + y_offset);
text_white.draw(
&text,
glyphs,
&c.draw_state,
transform,
g
).unwrap();
}
}
// for (i, &text) in cpu_register_texts.iter().enumerate() {
// let y_offset = (i+2) as f64 * (FT_LINE_DISTANCE + FT_SIZE_PX);
// let transform = c.transform.trans(offset[0], offset[1] + y_offset);
// text_white.draw(
// &text,
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// }
// }
fn render_disasm(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, disasm: &Disasm, pc: Addr, offset: [f64; 2]) {
let pc_position = disasm.addresses.iter().position(|&pos| pos == pc);
if let None = pc_position {
return;
}
let pc_position = pc_position.unwrap();
let lines_above_below: usize = 12;
// fn render_disasm(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, disasm: &Disasm, pc: Addr, offset: [f64; 2]) {
// let pc_position = disasm.addresses.iter().position(|&pos| pos == pc);
// if let None = pc_position {
// return;
// }
// let pc_position = pc_position.unwrap();
// let lines_above_below: usize = 12;
let start = if (pc_position as i32 - lines_above_below as i32) < 0 {
0
} else {
pc_position - lines_above_below
};
// let start = if (pc_position as i32 - lines_above_below as i32) < 0 {
// 0
// } else {
// pc_position - lines_above_below
// };
let mut transform = c.transform.trans(offset[0], offset[1]);
let text_current = Text::new_color(FT_COLOR_RED, FT_SIZE_PT);
let text_other = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
// let mut transform = c.transform.trans(offset[0], offset[1]);
// let text_current = Text::new_color(FT_COLOR_RED, FT_SIZE_PT);
// let text_other = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
for i in (start..disasm.addresses.len()).take(lines_above_below*2+1) {
let addr = disasm.addresses[i];
let txt = &disasm.instructions[i];
// for i in (start..disasm.addresses.len()).take(lines_above_below*2+1) {
// let addr = disasm.addresses[i];
// let txt = &disasm.instructions[i];
transform = transform.trans(0.0, FT_LINE_DISTANCE + FT_SIZE_PX);
let text = if addr == pc {
text_current
} else {
text_other
};
text.draw(
txt,
glyphs,
&c.draw_state,
transform,
g
).unwrap();
}
// transform = transform.trans(0.0, FT_LINE_DISTANCE + FT_SIZE_PX);
// let text = if addr == pc {
// text_current
// } else {
// text_other
// };
// text.draw(
// txt,
// glyphs,
// &c.draw_state,
// transform,
// g
// ).unwrap();
// }
}
// }
fn render_memory(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, bus: &MemoryBus, offset: [f64; 2]) {
let mut transform_y = c.transform.trans(offset[0], offset[1]);
let text = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
for page in (0x0000..0x01FF).step_by(16) {
transform_y = transform_y.trans(0.0, FT_LINE_DISTANCE+FT_SIZE_PX);
text.draw(
&format!("{:#06x}:", page),
glyphs,
&c.draw_state,
transform_y,
g
).unwrap();
let mut transform_x = transform_y.trans(40.0, 0.0);
for offset in 0u16..16u16 {
transform_x = transform_x.trans(20.0, 0.0);
let addr = page + offset;
text.draw(
&format!("{:02x}", bus.readb(addr)),
glyphs,
&c.draw_state,
transform_x,
g
).unwrap();
}
}
// fn render_memory(c: &Context, g: &mut G2d, glyphs: &mut Glyphs, bus: &MemoryBus, offset: [f64; 2]) {
// let mut transform_y = c.transform.trans(offset[0], offset[1]);
// let text = Text::new_color(FT_COLOR_WHITE, FT_SIZE_PT);
// for page in (0x0000..0x01FF).step_by(16) {
// transform_y = transform_y.trans(0.0, FT_LINE_DISTANCE+FT_SIZE_PX);
// text.draw(
// &format!("{:#06x}:", page),
// glyphs,
// &c.draw_state,
// transform_y,
// g
// ).unwrap();
// let mut transform_x = transform_y.trans(40.0, 0.0);
// for offset in 0u16..16u16 {
// transform_x = transform_x.trans(20.0, 0.0);
// let addr = page + offset;
// text.draw(
// &format!("{:02x}", bus.readb(addr)),
// glyphs,
// &c.draw_state,
// transform_x,
// g
// ).unwrap();
// }
// }
transform_y = transform_y.trans(0.0, (FT_LINE_DISTANCE+FT_SIZE_PX) * 1.5);
for page in (0x6000..0x6030).step_by(16) {
transform_y = transform_y.trans(0.0, (FT_LINE_DISTANCE+FT_SIZE_PX));
text.draw(
&format!("{:#06x}:", page),
glyphs,
&c.draw_state,
transform_y,
g
).unwrap();
let mut transform_x = transform_y.trans(40.0, 0.0);
for offset in 0u16..16u16 {
transform_x = transform_x.trans(20.0, 0.0);
let addr = page + offset;
text.draw(
&format!("{:02x}", bus.readb(addr)),
glyphs,
&c.draw_state,
transform_x,
g
).unwrap();
}
}
}
// transform_y = transform_y.trans(0.0, (FT_LINE_DISTANCE+FT_SIZE_PX) * 1.5);
// for page in (0x6000..0x6030).step_by(16) {
// transform_y = transform_y.trans(0.0, (FT_LINE_DISTANCE+FT_SIZE_PX));
// text.draw(
// &format!("{:#06x}:", page),
// glyphs,
// &c.draw_state,
// transform_y,
// g
// ).unwrap();
// let mut transform_x = transform_y.trans(40.0, 0.0);
// for offset in 0u16..16u16 {
// transform_x = transform_x.trans(20.0, 0.0);
// let addr = page + offset;
// text.draw(
// &format!("{:02x}", bus.readb(addr)),
// glyphs,
// &c.draw_state,
// transform_x,
// g
// ).unwrap();
// }
// }
// }

8
src/nes/cpu.rs
View File

@@ -454,8 +454,12 @@ impl CPU {
unimplemented!()
}
fn op_INC<T: Memory>(&mut self, bus: &T, val: Word) {
unimplemented!()
fn op_INC<T: Memory>(&mut self, bus: &mut T, addr: Word) {
let val = self.readb(bus, addr);
let val = val.wrapping_add(1);
self.writeb(bus, addr, val);
self.set_flag(ZERO, val == 0);
self.set_flag(NEGATIVE, (val & 0x80) != 0)
}
fn op_INX<T: Memory>(&mut self, bus: &T) {

42
src/render.rs Normal file
View File

@@ -0,0 +1,42 @@
use gfx_device_gl::Factory;
use gfx_device_gl::Resources;
use crate::nes::cpu::CPU;
use gfx_glyph::{Section,GlyphBrush};
pub trait Draw {
fn draw(&mut self, glyphs: &mut GlyphBrush<Resources,Factory>);
}
pub struct CPURenderer<'a> {
registers_text: String,
registers_section: Section<'a>,
}
impl<'a> CPURenderer<'a> {
pub fn new(cpu: &CPU) -> Self {
let registers_text = String::from("A: 0x00 (000)");
let registers_section = Section {
text: "xxx",
screen_position: (100.0, 100.0),
color: [1.0; 4],
..Section::default()
};
CPURenderer {
registers_text: registers_text,
registers_section: registers_section,
}
}
}
impl<'a> CPURenderer<'a> {
pub fn update(&mut self, cpu: &CPU) {
self.registers_text.replace_range(3..7, "txtx");
// self.registers_section.text = &self.registers_text;
}
}
impl<'a> Draw for CPURenderer<'a> {
fn draw(&mut self, glyphs: &mut GlyphBrush<Resources,Factory>) {
glyphs.queue(self.registers_section);
}
}