lemur/src/window/vram/chardata.rs

434 lines
16 KiB
Rust
Raw Normal View History

use std::{fmt::Display, sync::Arc};
2025-02-02 20:16:11 +00:00
use egui::{
Align, CentralPanel, Color32, ColorImage, ComboBox, Context, Frame, Image, RichText,
ScrollArea, Sense, Slider, TextEdit, TextureOptions, Ui, UiBuilder, Vec2, ViewportBuilder,
ViewportId,
2025-02-02 20:16:11 +00:00
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use serde::{Deserialize, Serialize};
2025-02-02 20:16:11 +00:00
use crate::{
emulator::SimId,
memory::{MemoryMonitor, MemoryView},
vram::{VramImageLoader, VramResource as _, VramTextureLoader},
2025-02-02 23:33:59 +00:00
window::AppWindow,
2025-02-02 20:16:11 +00:00
};
use super::utils;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VramPalette {
Generic,
Bg0,
Bg1,
Bg2,
Bg3,
Obj0,
Obj1,
Obj2,
Obj3,
}
impl VramPalette {
pub const fn values() -> [VramPalette; 9] {
[
Self::Generic,
Self::Bg0,
Self::Bg1,
Self::Bg2,
Self::Bg3,
Self::Obj0,
Self::Obj1,
Self::Obj2,
Self::Obj3,
]
}
pub const fn offset(self) -> Option<usize> {
match self {
Self::Generic => None,
Self::Bg0 => Some(0),
Self::Bg1 => Some(2),
Self::Bg2 => Some(4),
Self::Bg3 => Some(6),
Self::Obj0 => Some(8),
Self::Obj1 => Some(10),
Self::Obj2 => Some(12),
Self::Obj3 => Some(14),
}
}
}
impl Display for VramPalette {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Generic => f.write_str("Generic"),
Self::Bg0 => f.write_str("BG 0"),
Self::Bg1 => f.write_str("BG 1"),
Self::Bg2 => f.write_str("BG 2"),
Self::Bg3 => f.write_str("BG 3"),
Self::Obj0 => f.write_str("OBJ 0"),
Self::Obj1 => f.write_str("OBJ 1"),
Self::Obj2 => f.write_str("OBJ 2"),
Self::Obj3 => f.write_str("OBJ 3"),
}
}
}
2025-02-02 20:16:11 +00:00
pub struct CharacterDataWindow {
sim_id: SimId,
loader: Option<CharDataLoader>,
brightness: MemoryView,
palettes: MemoryView,
2025-02-02 20:16:11 +00:00
palette: VramPalette,
index: usize,
index_str: String,
scale: f32,
show_grid: bool,
}
impl CharacterDataWindow {
pub fn new(sim_id: SimId, memory: &mut MemoryMonitor) -> Self {
2025-02-02 20:16:11 +00:00
Self {
sim_id,
loader: Some(CharDataLoader::new(sim_id, memory)),
brightness: memory.view(sim_id, 0x0005f824, 8),
palettes: memory.view(sim_id, 0x0005f860, 16),
2025-02-02 20:16:11 +00:00
palette: VramPalette::Generic,
index: 0,
index_str: "0".into(),
scale: 4.0,
show_grid: true,
}
}
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("Index");
});
row.col(|ui| {
let res = ui.add(
TextEdit::singleline(&mut self.index_str)
.horizontal_align(Align::Max),
);
if res.changed() {
if let Some(index) =
self.index_str.parse().ok().filter(|id| *id < 2048)
{
self.index = index;
}
}
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Address");
});
row.col(|ui| {
let address = match self.index {
0x000..0x200 => 0x00060000 + self.index,
0x200..0x400 => 0x000e0000 + (self.index - 0x200),
0x400..0x600 => 0x00160000 + (self.index - 0x400),
0x600..0x800 => 0x001e0000 + (self.index - 0x600),
_ => unreachable!("can't happen"),
};
let mut address_str = format!("{address:08x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut address_str).horizontal_align(Align::Max),
);
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Mirror");
});
row.col(|ui| {
let mirror = 0x00078000 + (self.index * 16);
let mut mirror_str = format!("{mirror:08x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut mirror_str).horizontal_align(Align::Max),
);
});
});
});
let resource = CharDataResource::Character {
palette: self.palette,
index: self.index,
};
2025-02-02 20:16:11 +00:00
let image = Image::new(resource.to_uri())
.maintain_aspect_ratio(true)
.tint(Color32::RED)
.texture_options(TextureOptions::NEAREST);
ui.add(image);
ui.section("Colors", |ui| {
ui.horizontal(|ui| {
ui.label("Palette");
ComboBox::from_id_salt("palette")
.selected_text(self.palette.to_string())
.width(ui.available_width())
.show_ui(ui, |ui| {
for palette in VramPalette::values() {
ui.selectable_value(
&mut self.palette,
palette,
palette.to_string(),
);
}
});
});
TableBuilder::new(ui)
.columns(Column::remainder(), 4)
.body(|mut body| {
let palette = self.load_palette_colors();
2025-02-02 20:16:11 +00:00
body.row(30.0, |mut row| {
for color in palette {
2025-02-02 20:16:11 +00:00
row.col(|ui| {
let rect = ui.available_rect_before_wrap();
let scale = rect.height() / rect.width();
let rect = rect.scale_from_center2(Vec2::new(scale, 1.0));
ui.painter().rect_filled(
rect,
0.0,
Color32::RED * Color32::from_gray(color),
);
2025-02-02 20:16:11 +00:00
});
}
});
});
});
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");
});
});
}
fn load_palette_colors(&self) -> [u8; 4] {
let Some(offset) = self.palette.offset() else {
return utils::GENERIC_PALETTE;
};
let palette = self.palettes.borrow().read(offset);
let brightnesses = self.brightness.borrow();
let brts = brightnesses.range(0, 8);
utils::parse_palette(palette, brts)
}
2025-02-02 20:16:11 +00:00
fn show_chardata(&mut self, ui: &mut Ui) {
let start_pos = ui.cursor().min;
let resource = CharDataResource::CharacterData {
palette: self.palette,
};
2025-02-02 20:16:11 +00:00
let image = Image::new(resource.to_uri())
.fit_to_original_size(self.scale)
.tint(Color32::RED)
.texture_options(TextureOptions::NEAREST)
.sense(Sense::click());
let res = ui.add(image);
if res.clicked() {
if let Some(click_pos) = res.interact_pointer_pos() {
let fixed_pos = (click_pos - start_pos) / self.scale;
let x = (fixed_pos.x / 8.0) as usize;
let y = (fixed_pos.y / 8.0) as usize;
self.index = (y * 16) + x;
self.index_str = self.index.to_string();
}
}
let painter = ui.painter_at(res.rect);
if self.show_grid {
let stroke = ui.style().visuals.widgets.noninteractive.fg_stroke;
for x in (1..16).map(|i| (i as f32) * 8.0 * self.scale) {
let p1 = res.rect.min + (x, 0.0).into();
let p2 = res.rect.min + (x, 128.0 * 8.0 * self.scale).into();
painter.line(vec![p1, p2], stroke);
}
for y in (1..128).map(|i| (i as f32) * 8.0 * self.scale) {
let p1 = res.rect.min + (0.0, y).into();
let p2 = res.rect.min + (16.0 * 8.0 * self.scale, y).into();
painter.line(vec![p1, p2], stroke);
}
}
// draw box around selected
let x1 = (self.index % 16) as f32 * 8.0 * self.scale;
let x2 = x1 + (8.0 * self.scale);
let y1 = (self.index / 16) as f32 * 8.0 * self.scale;
let y2 = y1 + (8.0 * self.scale);
painter.line(
vec![
(res.rect.min + (x1, y1).into()),
(res.rect.min + (x2, y1).into()),
(res.rect.min + (x2, y2).into()),
(res.rect.min + (x1, y2).into()),
(res.rect.min + (x1, y1).into()),
],
ui.style().visuals.widgets.active.fg_stroke,
);
}
}
impl AppWindow for CharacterDataWindow {
fn viewport_id(&self) -> ViewportId {
ViewportId::from_hash_of(format!("chardata-{}", self.sim_id))
}
fn sim_id(&self) -> SimId {
self.sim_id
}
fn initial_viewport(&self) -> ViewportBuilder {
ViewportBuilder::default()
.with_title(format!("Character Data ({})", self.sim_id))
.with_inner_size((640.0, 480.0))
}
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
let loader = self.loader.take().unwrap();
ctx.add_texture_loader(Arc::new(VramTextureLoader::new(loader)));
}
2025-02-02 20:16:11 +00:00
fn show(&mut self, ctx: &Context) {
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_chardata(ui));
});
});
});
});
}
}
#[derive(Serialize, Deserialize, PartialEq, Eq, Hash)]
enum CharDataResource {
Character { palette: VramPalette, index: usize },
CharacterData { palette: VramPalette },
}
struct CharDataLoader {
chardata: MemoryView,
brightness: MemoryView,
palettes: MemoryView,
}
impl CharDataLoader {
pub fn new(sim_id: SimId, memory: &mut MemoryMonitor) -> Self {
Self {
chardata: memory.view(sim_id, 0x00078000, 0x8000),
brightness: memory.view(sim_id, 0x0005f824, 8),
palettes: memory.view(sim_id, 0x0005f860, 16),
}
}
fn load_character(&self, palette: VramPalette, index: usize) -> Option<ColorImage> {
if index >= 2048 {
return None;
}
let palette = self.load_palette(palette);
let chardata = self.chardata.borrow();
let character = chardata.range::<u16>(index * 8, 8);
let mut buffer = Vec::with_capacity(8 * 8);
for row in character {
for offset in (0..16).step_by(2) {
let char = (row >> offset) & 0x3;
buffer.push(palette[char as usize]);
}
}
Some(ColorImage::from_gray([8, 8], &buffer))
}
fn load_character_data(&self, palette: VramPalette) -> Option<ColorImage> {
let palette = self.load_palette(palette);
let chardata = self.chardata.borrow();
let mut buffer = vec![0; 8 * 8 * 2048];
for (i, row) in chardata.range::<u16>(0, 2048).iter().enumerate() {
let bytes =
[0, 2, 4, 6, 8, 10, 12, 14].map(|off| palette[(*row as usize >> off) & 0x3]);
let char_index = i / 8;
let row_index = i % 8;
let x = (char_index % 16) * 8;
let y = (char_index / 16) * 8 + row_index;
let write_index = (y * 16 * 8) + x;
buffer[write_index..write_index + 8].copy_from_slice(&bytes);
}
Some(ColorImage::from_gray([8 * 16, 8 * 128], &buffer))
}
fn load_palette(&self, palette: VramPalette) -> [u8; 4] {
let Some(offset) = palette.offset() else {
return utils::GENERIC_PALETTE;
};
let palette = self.palettes.borrow().read(offset);
let brightnesses = self.brightness.borrow();
let brts = brightnesses.range(0, 8);
utils::parse_palette(palette, brts)
}
}
impl VramImageLoader for CharDataLoader {
type Resource = CharDataResource;
fn id(&self) -> &str {
concat!(module_path!(), "::CharDataLoader")
}
fn add(&self, resource: &Self::Resource) -> Option<ColorImage> {
match resource {
CharDataResource::Character { palette, index } => self.load_character(*palette, *index),
CharDataResource::CharacterData { palette } => self.load_character_data(*palette),
}
}
fn update<'a>(
&'a self,
resources: impl Iterator<Item = &'a Self::Resource>,
) -> Vec<(&'a Self::Resource, ColorImage)> {
let _ = resources;
vec![]
}
}
2025-02-02 20:16:11 +00:00
trait UiExt {
fn section(&mut self, title: impl Into<String>, add_contents: impl FnOnce(&mut Ui));
}
impl UiExt for Ui {
fn section(&mut self, title: impl Into<String>, add_contents: impl FnOnce(&mut Ui)) {
let mut frame = Frame::group(self.style());
frame.outer_margin.top += 10.0;
frame.inner_margin.top += 2.0;
let res = frame.show(self, add_contents);
let text = RichText::new(title).background_color(self.style().visuals.panel_fill);
let old_rect = res.response.rect;
let mut text_rect = old_rect;
text_rect.min.x += 6.0;
let new_rect = self
.allocate_new_ui(UiBuilder::new().max_rect(text_rect), |ui| ui.label(text))
.response
.rect;
self.allocate_space((old_rect.max - new_rect.max) - (old_rect.min - new_rect.min));
}
}