373 lines
13 KiB
Rust
373 lines
13 KiB
Rust
use std::sync::Arc;
|
|
|
|
use egui::{
|
|
Align, CentralPanel, Checkbox, Color32, Context, Image, ScrollArea, Slider, TextEdit,
|
|
TextureOptions, Ui, ViewportBuilder, ViewportId,
|
|
};
|
|
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::{
|
|
emulator::SimId,
|
|
memory::{MemoryMonitor, MemoryView},
|
|
vram::{VramImage, VramImageLoader, VramResource as _, VramTextureLoader},
|
|
window::{utils::UiExt, AppWindow},
|
|
};
|
|
|
|
use super::utils::{parse_palette, CharacterGrid, GENERIC_PALETTE};
|
|
|
|
pub struct BgMapWindow {
|
|
sim_id: SimId,
|
|
loader: Arc<VramTextureLoader<BgMapLoader>>,
|
|
bgmaps: MemoryView,
|
|
cell_index: usize,
|
|
cell_index_str: String,
|
|
scale: f32,
|
|
show_grid: bool,
|
|
generic_palette: bool,
|
|
}
|
|
|
|
impl BgMapWindow {
|
|
pub fn new(sim_id: SimId, memory: &mut MemoryMonitor) -> Self {
|
|
Self {
|
|
sim_id,
|
|
loader: Arc::new(VramTextureLoader::new(BgMapLoader::new(sim_id, memory))),
|
|
bgmaps: memory.view(sim_id, 0x00020000, 0x1d800),
|
|
cell_index: 0,
|
|
cell_index_str: "0".into(),
|
|
scale: 1.0,
|
|
show_grid: false,
|
|
generic_palette: false,
|
|
}
|
|
}
|
|
|
|
fn show_form(&mut self, ui: &mut Ui) {
|
|
let row_height = ui.spacing().interact_size.y;
|
|
ui.vertical(|ui| {
|
|
TableBuilder::new(ui)
|
|
.column(Column::auto())
|
|
.column(Column::remainder())
|
|
.body(|mut body| {
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
ui.label("Map");
|
|
});
|
|
row.col(|ui| {
|
|
let mut bgmap_index = self.cell_index / 4096;
|
|
let mut bgmap_index_str = bgmap_index.to_string();
|
|
ui.number_picker(&mut bgmap_index_str, &mut bgmap_index, 0..14);
|
|
if bgmap_index != self.cell_index / 4096 {
|
|
self.cell_index = (bgmap_index * 4096) + (self.cell_index % 4096);
|
|
self.cell_index_str = self.cell_index.to_string();
|
|
}
|
|
});
|
|
});
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
ui.label("Cell");
|
|
});
|
|
row.col(|ui| {
|
|
ui.number_picker(
|
|
&mut self.cell_index_str,
|
|
&mut self.cell_index,
|
|
0..16 * 4096,
|
|
);
|
|
});
|
|
});
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
ui.label("Address");
|
|
});
|
|
row.col(|ui| {
|
|
let address = 0x00020000 + (self.cell_index * 2);
|
|
let mut address_str = format!("{address:08x}");
|
|
ui.add_enabled(
|
|
false,
|
|
TextEdit::singleline(&mut address_str).horizontal_align(Align::Max),
|
|
);
|
|
});
|
|
});
|
|
});
|
|
let resource = BgMapResource::Cell {
|
|
index: self.cell_index,
|
|
generic_palette: self.generic_palette,
|
|
};
|
|
let image = Image::new(resource.to_uri())
|
|
.maintain_aspect_ratio(true)
|
|
.tint(Color32::RED)
|
|
.texture_options(TextureOptions::NEAREST);
|
|
ui.add(image);
|
|
ui.section("Cell", |ui| {
|
|
let cell = self.bgmaps.borrow().read::<u16>(self.cell_index);
|
|
let (char_index, mut vflip, mut hflip, palette_index) = parse_cell(cell);
|
|
TableBuilder::new(ui)
|
|
.column(Column::remainder())
|
|
.column(Column::remainder())
|
|
.body(|mut body| {
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
ui.label("Character");
|
|
});
|
|
row.col(|ui| {
|
|
let mut character_str = char_index.to_string();
|
|
ui.add_enabled(
|
|
false,
|
|
TextEdit::singleline(&mut character_str)
|
|
.horizontal_align(Align::Max),
|
|
);
|
|
});
|
|
});
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
ui.label("Palette");
|
|
});
|
|
row.col(|ui| {
|
|
let mut palette = format!("BG {}", palette_index);
|
|
ui.add_enabled(
|
|
false,
|
|
TextEdit::singleline(&mut palette).horizontal_align(Align::Max),
|
|
);
|
|
});
|
|
});
|
|
body.row(row_height, |mut row| {
|
|
row.col(|ui| {
|
|
let checkbox = Checkbox::new(&mut hflip, "H-flip");
|
|
ui.add_enabled(false, checkbox);
|
|
});
|
|
row.col(|ui| {
|
|
let checkbox = Checkbox::new(&mut vflip, "V-flip");
|
|
ui.add_enabled(false, checkbox);
|
|
});
|
|
});
|
|
});
|
|
ui.section("Display", |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("Scale");
|
|
ui.spacing_mut().slider_width = ui.available_width();
|
|
let slider = Slider::new(&mut self.scale, 1.0..=10.0)
|
|
.step_by(1.0)
|
|
.show_value(false);
|
|
ui.add(slider);
|
|
});
|
|
ui.checkbox(&mut self.show_grid, "Show grid");
|
|
ui.checkbox(&mut self.generic_palette, "Generic palette");
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
fn show_bgmap(&mut self, ui: &mut Ui) {
|
|
let resource = BgMapResource::BgMap {
|
|
index: self.cell_index / 4096,
|
|
generic_palette: self.generic_palette,
|
|
};
|
|
let grid = CharacterGrid::new(resource.to_uri())
|
|
.with_scale(self.scale)
|
|
.with_grid(self.show_grid)
|
|
.with_selected(self.cell_index % 4096);
|
|
if let Some(selected) = grid.show(ui) {
|
|
self.cell_index = (self.cell_index / 4096 * 4096) + selected;
|
|
self.cell_index_str = self.cell_index.to_string();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AppWindow for BgMapWindow {
|
|
fn viewport_id(&self) -> ViewportId {
|
|
ViewportId::from_hash_of(format!("bgmap-{}", self.sim_id))
|
|
}
|
|
|
|
fn sim_id(&self) -> SimId {
|
|
self.sim_id
|
|
}
|
|
|
|
fn initial_viewport(&self) -> ViewportBuilder {
|
|
ViewportBuilder::default()
|
|
.with_title(format!("BG Map Data ({})", self.sim_id))
|
|
.with_inner_size((640.0, 480.0))
|
|
}
|
|
|
|
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
|
ctx.add_texture_loader(self.loader.clone());
|
|
}
|
|
|
|
fn show(&mut self, ctx: &Context) {
|
|
self.loader.begin_pass();
|
|
CentralPanel::default().show(ctx, |ui| {
|
|
ui.horizontal_top(|ui| {
|
|
StripBuilder::new(ui)
|
|
.size(Size::relative(0.3))
|
|
.size(Size::remainder())
|
|
.horizontal(|mut strip| {
|
|
strip.cell(|ui| {
|
|
ScrollArea::vertical().show(ui, |ui| self.show_form(ui));
|
|
});
|
|
strip.cell(|ui| {
|
|
ScrollArea::both().show(ui, |ui| self.show_bgmap(ui));
|
|
});
|
|
})
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
fn parse_cell(cell: u16) -> (usize, bool, bool, usize) {
|
|
let char_index = (cell & 0x7ff) as usize;
|
|
let vflip = cell & 0x1000 != 0;
|
|
let hflip = cell & 0x2000 != 0;
|
|
let palette_index = (cell >> 14) as usize;
|
|
(char_index, vflip, hflip, palette_index)
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
|
|
enum BgMapResource {
|
|
BgMap { index: usize, generic_palette: bool },
|
|
Cell { index: usize, generic_palette: bool },
|
|
}
|
|
|
|
struct BgMapLoader {
|
|
chardata: MemoryView,
|
|
bgmaps: MemoryView,
|
|
brightness: MemoryView,
|
|
palettes: MemoryView,
|
|
}
|
|
|
|
impl BgMapLoader {
|
|
pub fn new(sim_id: SimId, memory: &mut MemoryMonitor) -> Self {
|
|
Self {
|
|
chardata: memory.view(sim_id, 0x00078000, 0x8000),
|
|
bgmaps: memory.view(sim_id, 0x00020000, 0x1d800),
|
|
brightness: memory.view(sim_id, 0x0005f824, 8),
|
|
palettes: memory.view(sim_id, 0x0005f860, 16),
|
|
}
|
|
}
|
|
|
|
fn update_bgmap(&self, image: &mut VramImage, bgmap_index: usize, generic_palette: bool) {
|
|
let chardata = self.chardata.borrow();
|
|
let bgmaps = self.bgmaps.borrow();
|
|
let brightness = self.brightness.borrow();
|
|
let palettes = self.palettes.borrow();
|
|
|
|
let brts = brightness.range::<u8>(0, 8);
|
|
let colors = if generic_palette {
|
|
[
|
|
GENERIC_PALETTE,
|
|
GENERIC_PALETTE,
|
|
GENERIC_PALETTE,
|
|
GENERIC_PALETTE,
|
|
]
|
|
} else {
|
|
[
|
|
parse_palette(palettes.read(0), brts),
|
|
parse_palette(palettes.read(2), brts),
|
|
parse_palette(palettes.read(4), brts),
|
|
parse_palette(palettes.read(6), brts),
|
|
]
|
|
};
|
|
|
|
for (i, cell) in bgmaps
|
|
.range::<u16>(bgmap_index * 4096, 4096)
|
|
.iter()
|
|
.enumerate()
|
|
{
|
|
let (char_index, vflip, hflip, palette_index) = parse_cell(*cell);
|
|
let char = chardata.range::<u16>(char_index * 8, 8);
|
|
let palette = &colors[palette_index];
|
|
|
|
for row in 0..8 {
|
|
let y = row + (i / 64) * 8;
|
|
for (col, pixel) in self.read_char_row(char, hflip, vflip, row).enumerate() {
|
|
let x = col + (i % 64) * 8;
|
|
image.write((x, y), palette[pixel as usize]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_bgmap_cell(&self, image: &mut VramImage, index: usize, generic_palette: bool) {
|
|
let chardata = self.chardata.borrow();
|
|
let bgmaps = self.bgmaps.borrow();
|
|
let brightness = self.brightness.borrow();
|
|
let palettes = self.palettes.borrow();
|
|
|
|
let brts = brightness.range::<u8>(0, 8);
|
|
|
|
let cell = bgmaps.read::<u16>(index);
|
|
|
|
let (char_index, vflip, hflip, palette_index) = parse_cell(cell);
|
|
let char = chardata.range::<u16>(char_index * 8, 8);
|
|
let palette = if generic_palette {
|
|
GENERIC_PALETTE
|
|
} else {
|
|
parse_palette(palettes.read(palette_index * 2), brts)
|
|
};
|
|
|
|
for row in 0..8 {
|
|
for (col, pixel) in self.read_char_row(char, hflip, vflip, row).enumerate() {
|
|
image.write((col, row), palette[pixel as usize]);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn read_char_row(
|
|
&self,
|
|
char: &[u16],
|
|
hflip: bool,
|
|
vflip: bool,
|
|
row: usize,
|
|
) -> impl Iterator<Item = u8> {
|
|
let pixels = if vflip { char[7 - row] } else { char[row] };
|
|
(0..16).step_by(2).map(move |i| {
|
|
let pixel = if hflip { 14 - i } else { i };
|
|
((pixels >> pixel) & 0x3) as u8
|
|
})
|
|
}
|
|
}
|
|
|
|
impl VramImageLoader for BgMapLoader {
|
|
type Resource = BgMapResource;
|
|
|
|
fn id(&self) -> &str {
|
|
concat!(module_path!(), "::BgMapLoader")
|
|
}
|
|
|
|
fn add(&self, resource: &Self::Resource) -> Option<VramImage> {
|
|
match resource {
|
|
BgMapResource::BgMap {
|
|
index,
|
|
generic_palette,
|
|
} => {
|
|
let mut image = VramImage::new(64 * 8, 64 * 8);
|
|
self.update_bgmap(&mut image, *index, *generic_palette);
|
|
Some(image)
|
|
}
|
|
BgMapResource::Cell {
|
|
index,
|
|
generic_palette,
|
|
} => {
|
|
let mut image = VramImage::new(8, 8);
|
|
self.update_bgmap_cell(&mut image, *index, *generic_palette);
|
|
Some(image)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update<'a>(
|
|
&'a self,
|
|
resources: impl Iterator<Item = (&'a Self::Resource, &'a mut VramImage)>,
|
|
) {
|
|
for (resource, image) in resources {
|
|
match resource {
|
|
BgMapResource::BgMap {
|
|
index,
|
|
generic_palette,
|
|
} => self.update_bgmap(image, *index, *generic_palette),
|
|
BgMapResource::Cell {
|
|
index,
|
|
generic_palette,
|
|
} => self.update_bgmap_cell(image, *index, *generic_palette),
|
|
}
|
|
}
|
|
}
|
|
}
|