PVB/lemur
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 50 Wiki Activity

Rename vram to vip internally

Browse Source
This commit is contained in:
SonicSwordcane
2025-02-23 22:44:11 -05:00
parent 0ae2a2f54f
commit 6ab9d2ee53
13 changed files with 125 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/window/vip/bgmap.rs
+315
View File
@@ -0,0 +1,315 @@
use std::sync::Arc;
use egui::{
Align, CentralPanel, Checkbox, Color32, ComboBox, Context, Image, ScrollArea, Slider, TextEdit,
TextureOptions, Ui, ViewportBuilder, ViewportId,
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{
emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView},
window::{
utils::{NumberEdit, UiExt},
AppWindow,
},
};
use super::utils::{self, CellData, CharacterGrid};
pub struct BgMapWindow {
sim_id: SimId,
loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>,
bgmaps: MemoryView,
cell_index: usize,
generic_palette: bool,
params: ImageParams<BgMapParams>,
scale: f32,
show_grid: bool,
}
impl BgMapWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, images: &mut ImageProcessor) -> Self {
let renderer = BgMapRenderer::new(sim_id, memory);
let ([cell, bgmap], params) = images.add(renderer, BgMapParams::default());
let loader =
ImageTextureLoader::new([("vip://cell".into(), cell), ("vip://bgmap".into(), bgmap)]);
Self {
sim_id,
loader: Arc::new(loader),
memory: memory.clone(),
bgmaps: memory.watch(sim_id, 0x00020000, 0x20000),
cell_index: params.cell_index,
generic_palette: params.generic_palette,
params,
scale: 1.0,
show_grid: 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;
ui.add(NumberEdit::new(&mut bgmap_index).range(0..16));
if bgmap_index != self.cell_index / 4096 {
self.cell_index = (bgmap_index * 4096) + (self.cell_index % 4096);
}
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Cell");
});
row.col(|ui| {
ui.add(NumberEdit::new(&mut self.cell_index).range(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 image = Image::new("vip://cell")
.maintain_aspect_ratio(true)
.texture_options(TextureOptions::NEAREST);
ui.add(image);
ui.section("Cell", |ui| {
let mut data = self.bgmaps.borrow().read::<u16>(self.cell_index);
let mut cell = CellData::parse(data);
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| {
ui.add(NumberEdit::new(&mut cell.char_index).range(0..2048));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Palette");
});
row.col(|ui| {
ComboBox::from_id_salt("palette")
.selected_text(format!("BG {}", cell.palette_index))
.width(ui.available_width())
.show_ui(ui, |ui| {
for palette in 0..4 {
ui.selectable_value(
&mut cell.palette_index,
palette,
format!("BG {palette}"),
);
}
});
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add(Checkbox::new(&mut cell.hflip, "H-flip"));
});
row.col(|ui| {
ui.add(Checkbox::new(&mut cell.vflip, "V-flip"));
});
});
});
if cell.update(&mut data) {
let address = 0x00020000 + (self.cell_index * 2);
self.memory.write(self.sim_id, address as u32, &data);
}
});
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");
});
});
self.params.write(BgMapParams {
cell_index: self.cell_index,
generic_palette: self.generic_palette,
});
}
fn show_bgmap(&mut self, ui: &mut Ui) {
let grid = CharacterGrid::new("vip://bgmap")
.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;
}
}
}
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) {
CentralPanel::default().show(ctx, |ui| {
ui.horizontal_top(|ui| {
StripBuilder::new(ui)
.size(Size::relative(0.3).at_most(200.0))
.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));
});
})
});
});
}
}
#[derive(Default, Clone, PartialEq, Eq)]
struct BgMapParams {
cell_index: usize,
generic_palette: bool,
}
struct BgMapRenderer {
chardata: MemoryView,
bgmaps: MemoryView,
brightness: MemoryView,
palettes: MemoryView,
}
impl BgMapRenderer {
pub fn new(sim_id: SimId, memory: &MemoryClient) -> Self {
Self {
chardata: memory.watch(sim_id, 0x00078000, 0x8000),
bgmaps: memory.watch(sim_id, 0x00020000, 0x20000),
brightness: memory.watch(sim_id, 0x0005f824, 8),
palettes: memory.watch(sim_id, 0x0005f860, 16),
}
}
fn render_bgmap(&self, image: &mut ImageBuffer, 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.read::<[u8; 8]>(0);
let colors = if generic_palette {
[utils::generic_palette(Color32::RED); 4]
} else {
[0, 2, 4, 6].map(|i| utils::palette_colors(palettes.read(i), &brts, Color32::RED))
};
for (i, cell) in bgmaps.range::<u16>(bgmap_index * 4096, 4096).enumerate() {
let CellData {
char_index,
vflip,
hflip,
palette_index,
} = CellData::parse(cell);
let char = chardata.read::<[u16; 8]>(char_index);
let palette = &colors[palette_index];
for row in 0..8 {
let y = row + (i / 64) * 8;
for (col, pixel) in utils::read_char_row(&char, hflip, vflip, row).enumerate() {
let x = col + (i % 64) * 8;
image.write((x, y), palette[pixel as usize]);
}
}
}
}
fn render_bgmap_cell(&self, image: &mut ImageBuffer, 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.read::<[u8; 8]>(0);
let cell = bgmaps.read::<u16>(index);
let CellData {
char_index,
vflip,
hflip,
palette_index,
} = CellData::parse(cell);
let char = chardata.read::<[u16; 8]>(char_index);
let palette = if generic_palette {
utils::generic_palette(Color32::RED)
} else {
utils::palette_colors(palettes.read(palette_index * 2), &brts, Color32::RED)
};
for row in 0..8 {
for (col, pixel) in utils::read_char_row(&char, hflip, vflip, row).enumerate() {
image.write((col, row), palette[pixel as usize]);
}
}
}
}
impl ImageRenderer<2> for BgMapRenderer {
type Params = BgMapParams;
fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [8 * 64, 8 * 64]]
}
fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 2]) {
self.render_bgmap_cell(&mut images[0], params.cell_index, params.generic_palette);
self.render_bgmap(
&mut images[1],
params.cell_index / 4096,
params.generic_palette,
);
}
}
src/window/vip/chardata.rs
+356
View File
@@ -0,0 +1,356 @@
use std::{fmt::Display, sync::Arc};
use egui::{
Align, CentralPanel, Color32, ComboBox, Context, Image, ScrollArea, Slider, TextEdit,
TextureOptions, Ui, Vec2, ViewportBuilder, ViewportId,
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use serde::{Deserialize, Serialize};
use crate::{
emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView},
window::{
utils::{NumberEdit, UiExt as _},
AppWindow,
},
};
use super::utils::{self, CharacterGrid};
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Palette {
#[default]
Generic,
Bg0,
Bg1,
Bg2,
Bg3,
Obj0,
Obj1,
Obj2,
Obj3,
}
impl Palette {
pub const fn values() -> [Palette; 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 Palette {
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"),
}
}
}
pub struct CharacterDataWindow {
sim_id: SimId,
loader: Arc<ImageTextureLoader>,
brightness: MemoryView,
palettes: MemoryView,
palette: Palette,
index: usize,
params: ImageParams<CharDataParams>,
scale: f32,
show_grid: bool,
}
impl CharacterDataWindow {
pub fn new(sim_id: SimId, memory: &MemoryClient, images: &mut ImageProcessor) -> Self {
let renderer = CharDataRenderer::new(sim_id, memory);
let ([char, chardata], params) = images.add(renderer, CharDataParams::default());
let loader = ImageTextureLoader::new([
("vip://char".into(), char),
("vip://chardata".into(), chardata),
]);
Self {
sim_id,
loader: Arc::new(loader),
brightness: memory.watch(sim_id, 0x0005f824, 8),
palettes: memory.watch(sim_id, 0x0005f860, 16),
palette: params.palette,
index: params.index,
params,
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| {
ui.add(NumberEdit::new(&mut self.index).range(0..2048));
});
});
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 * 16,
0x200..0x400 => 0x000e0000 + (self.index - 0x200) * 16,
0x400..0x600 => 0x00160000 + (self.index - 0x400) * 16,
0x600..0x800 => 0x001e0000 + (self.index - 0x600) * 16,
_ => 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 image = Image::new("vip://char")
.maintain_aspect_ratio(true)
.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 Palette::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();
body.row(30.0, |mut row| {
for color in palette {
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, color);
});
}
});
});
});
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");
});
});
self.params.write(CharDataParams {
palette: self.palette,
index: self.index,
});
}
fn load_palette_colors(&self) -> [Color32; 4] {
let Some(offset) = self.palette.offset() else {
return utils::generic_palette(Color32::RED);
};
let palette = self.palettes.borrow().read(offset);
let brightnesses = self.brightness.borrow();
let brts = brightnesses.read(0);
utils::palette_colors(palette, &brts, Color32::RED)
}
fn show_chardata(&mut self, ui: &mut Ui) {
let grid = CharacterGrid::new("vip://chardata")
.with_scale(self.scale)
.with_grid(self.show_grid)
.with_selected(self.index);
if let Some(selected) = grid.show(ui) {
self.index = selected;
}
}
}
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) {
ctx.add_texture_loader(self.loader.clone());
}
fn show(&mut self, ctx: &Context) {
CentralPanel::default().show(ctx, |ui| {
ui.horizontal_top(|ui| {
StripBuilder::new(ui)
.size(Size::relative(0.3).at_most(200.0))
.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, Clone, PartialEq, Eq, Hash)]
enum CharDataResource {
Character { palette: Palette, index: usize },
CharacterData { palette: Palette },
}
#[derive(Clone, Default, PartialEq, Eq)]
struct CharDataParams {
palette: Palette,
index: usize,
}
struct CharDataRenderer {
chardata: MemoryView,
brightness: MemoryView,
palettes: MemoryView,
}
impl ImageRenderer<2> for CharDataRenderer {
type Params = CharDataParams;
fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [16 * 8, 128 * 8]]
}
fn render(&mut self, params: &Self::Params, image: &mut [ImageBuffer; 2]) {
self.render_character(&mut image[0], params.palette, params.index);
self.render_character_data(&mut image[1], params.palette);
}
}
impl CharDataRenderer {
pub fn new(sim_id: SimId, memory: &MemoryClient) -> Self {
Self {
chardata: memory.watch(sim_id, 0x00078000, 0x8000),
brightness: memory.watch(sim_id, 0x0005f824, 8),
palettes: memory.watch(sim_id, 0x0005f860, 16),
}
}
fn render_character(&self, image: &mut ImageBuffer, palette: Palette, index: usize) {
if index >= 2048 {
return;
}
let palette = self.load_palette(palette);
let chardata = self.chardata.borrow();
let character = chardata.range::<u16>(index * 8, 8);
for (row, pixels) in character.enumerate() {
for col in 0..8 {
let char = (pixels >> (col * 2)) & 0x03;
image.write((col, row), palette[char as usize]);
}
}
}
fn render_character_data(&self, image: &mut ImageBuffer, palette: Palette) {
let palette = self.load_palette(palette);
let chardata = self.chardata.borrow();
for (row, pixels) in chardata.range::<u16>(0, 8 * 2048).enumerate() {
let char_index = row / 8;
let row_index = row % 8;
let x = (char_index % 16) * 8;
let y = (char_index / 16) * 8 + row_index;
for col in 0..8 {
let char = (pixels >> (col * 2)) & 0x03;
image.write((x + col, y), palette[char as usize]);
}
}
}
fn load_palette(&self, palette: Palette) -> [Color32; 4] {
let Some(offset) = palette.offset() else {
return utils::GENERIC_PALETTE.map(|p| utils::shade(p, Color32::RED));
};
let palette = self.palettes.borrow().read(offset);
let brightnesses = self.brightness.borrow();
let brts = brightnesses.read(0);
utils::palette_colors(palette, &brts, Color32::RED)
}
}
src/window/vip/framebuffer.rs
+267
View File
@@ -0,0 +1,267 @@
use std::sync::Arc;
use egui::{
Align, CentralPanel, Color32, Context, Image, ScrollArea, Slider, TextEdit, TextureOptions, Ui,
ViewportBuilder, ViewportId,
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{
emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView},
window::{
utils::{NumberEdit, UiExt as _},
AppWindow,
},
};
use super::utils;
pub struct FrameBufferWindow {
sim_id: SimId,
loader: Arc<ImageTextureLoader>,
index: usize,
left: bool,
right: bool,
generic_palette: bool,
params: ImageParams<FrameBufferParams>,
scale: f32,
}
impl FrameBufferWindow {
pub fn new(sim_id: SimId, memory: &MemoryClient, images: &mut ImageProcessor) -> Self {
let initial_params = FrameBufferParams {
index: 0,
left: true,
right: true,
generic_palette: false,
left_color: Color32::from_rgb(0xff, 0x00, 0x00),
right_color: Color32::from_rgb(0x00, 0xc6, 0xf0),
};
let renderer = FrameBufferRenderer::new(sim_id, memory);
let ([buffer], params) = images.add(renderer, initial_params);
let loader = ImageTextureLoader::new([("vip://buffer".into(), buffer)]);
Self {
sim_id,
loader: Arc::new(loader),
index: params.index,
left: params.left,
right: params.right,
generic_palette: params.generic_palette,
params,
scale: 2.0,
}
}
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| {
ui.add(NumberEdit::new(&mut self.index).range(0..2));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Left");
});
row.col(|ui| {
let address = self.index * 0x00008000;
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("Right");
});
row.col(|ui| {
let address = self.index * 0x00008000 + 0x00010000;
let mut address_str = format!("{address:08x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut address_str).horizontal_align(Align::Max),
);
});
});
});
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);
});
TableBuilder::new(ui)
.columns(Column::remainder(), 2)
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.checkbox(&mut self.left, "Left");
});
row.col(|ui| {
ui.checkbox(&mut self.right, "Right");
});
});
});
ui.checkbox(&mut self.generic_palette, "Generic colors");
});
});
self.params.write(FrameBufferParams {
index: self.index,
left: self.left,
right: self.right,
generic_palette: self.generic_palette,
..*self.params
});
}
fn show_buffers(&mut self, ui: &mut Ui) {
let image = Image::new("vip://buffer")
.fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST);
ui.add(image);
}
}
impl AppWindow for FrameBufferWindow {
fn viewport_id(&self) -> ViewportId {
ViewportId::from_hash_of(format!("framebuffer-{}", self.sim_id))
}
fn sim_id(&self) -> SimId {
self.sim_id
}
fn initial_viewport(&self) -> ViewportBuilder {
ViewportBuilder::default()
.with_title(format!("Frame Buffers ({})", 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) {
CentralPanel::default().show(ctx, |ui| {
ui.horizontal_top(|ui| {
StripBuilder::new(ui)
.size(Size::relative(0.3).at_most(200.0))
.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_buffers(ui));
});
});
});
});
}
}
#[derive(Clone, PartialEq, Eq)]
struct FrameBufferParams {
index: usize,
left: bool,
right: bool,
generic_palette: bool,
left_color: Color32,
right_color: Color32,
}
struct FrameBufferRenderer {
buffers: [MemoryView; 4],
brightness: MemoryView,
}
impl FrameBufferRenderer {
fn new(sim_id: SimId, memory: &MemoryClient) -> Self {
Self {
buffers: [
memory.watch(sim_id, 0x00000000, 0x6000),
memory.watch(sim_id, 0x00008000, 0x6000),
memory.watch(sim_id, 0x00010000, 0x6000),
memory.watch(sim_id, 0x00018000, 0x6000),
],
brightness: memory.watch(sim_id, 0x0005f824, 8),
}
}
}
impl ImageRenderer<1> for FrameBufferRenderer {
type Params = FrameBufferParams;
fn sizes(&self) -> [[usize; 2]; 1] {
[[384, 224]]
}
fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 1]) {
let image = &mut images[0];
let left_buffer = self.buffers[params.index * 2].borrow();
let right_buffer = self.buffers[params.index * 2 + 1].borrow();
let colors = if params.generic_palette {
[
utils::generic_palette(params.left_color),
utils::generic_palette(params.right_color),
]
} else {
let brts = self.brightness.borrow().read::<[u8; 8]>(0);
let shades = utils::parse_shades(&brts);
[
shades.map(|s| utils::shade(s, params.left_color)),
shades.map(|s| utils::shade(s, params.right_color)),
]
};
let left_cols = left_buffer.range::<u8>(0, 0x6000);
let right_cols = right_buffer.range::<u8>(0, 0x6000);
for (index, (left, right)) in left_cols.zip(right_cols).enumerate() {
let top = (index % 64) * 4;
if top >= 224 {
continue;
}
let pixels = [0, 2, 4, 6].map(|i| {
let left = if params.left {
colors[0][(left >> i) as usize & 0x3]
} else {
Color32::BLACK
};
let right = if params.right {
colors[1][(right >> i) as usize & 0x3]
} else {
Color32::BLACK
};
Color32::from_rgb(
left.r() + right.r(),
left.g() + right.g(),
left.b() + right.b(),
)
});
let x = index / 64;
for (i, pixel) in pixels.into_iter().enumerate() {
let y = top + i;
image.write((x, y), pixel);
}
}
}
}
src/window/vip/object.rs
+342
View File
@@ -0,0 +1,342 @@
use std::sync::Arc;
use egui::{
Align, CentralPanel, Checkbox, Color32, ComboBox, Context, Image, ScrollArea, Slider, TextEdit,
TextureOptions, Ui, ViewportBuilder, ViewportId,
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{
emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView},
window::{
utils::{NumberEdit, UiExt as _},
AppWindow,
},
};
use super::utils::{self, Object};
pub struct ObjectWindow {
sim_id: SimId,
loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>,
objects: MemoryView,
index: usize,
generic_palette: bool,
params: ImageParams<ObjectParams>,
scale: f32,
}
impl ObjectWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, images: &mut ImageProcessor) -> Self {
let initial_params = ObjectParams {
index: 0,
generic_palette: false,
left_color: Color32::from_rgb(0xff, 0x00, 0x00),
right_color: Color32::from_rgb(0x00, 0xc6, 0xf0),
};
let renderer = ObjectRenderer::new(sim_id, memory);
let ([zoom, full], params) = images.add(renderer, initial_params);
let loader =
ImageTextureLoader::new([("vip://zoom".into(), zoom), ("vip://full".into(), full)]);
Self {
sim_id,
loader: Arc::new(loader),
memory: memory.clone(),
objects: memory.watch(sim_id, 0x0003e000, 0x2000),
index: params.index,
generic_palette: params.generic_palette,
params,
scale: 1.0,
}
}
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| {
ui.add(NumberEdit::new(&mut self.index).range(0..1024));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Address");
});
row.col(|ui| {
let address = 0x3e000 + self.index * 8;
let mut address_str = format!("{address:08x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut address_str).horizontal_align(Align::Max),
);
});
});
});
let image = Image::new("vip://zoom")
.maintain_aspect_ratio(true)
.texture_options(TextureOptions::NEAREST);
ui.add(image);
ui.section("Properties", |ui| {
let mut object = self.objects.borrow().read::<[u16; 4]>(self.index);
let mut obj = Object::parse(object);
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| {
ui.add(NumberEdit::new(&mut obj.data.char_index).range(0..2048));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Palette");
});
row.col(|ui| {
ComboBox::from_id_salt("palette")
.selected_text(format!("OBJ {}", obj.data.palette_index))
.width(ui.available_width())
.show_ui(ui, |ui| {
for palette in 0..4 {
ui.selectable_value(
&mut obj.data.palette_index,
palette,
format!("OBJ {palette}"),
);
}
});
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("X");
});
row.col(|ui| {
ui.add(NumberEdit::new(&mut obj.x).range(-512..512));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Y");
});
row.col(|ui| {
ui.add(NumberEdit::new(&mut obj.y).range(-8..=224));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("Parallax");
});
row.col(|ui| {
ui.add(NumberEdit::new(&mut obj.parallax).range(-512..512));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add(Checkbox::new(&mut obj.data.hflip, "H-flip"));
});
row.col(|ui| {
ui.add(Checkbox::new(&mut obj.data.vflip, "V-flip"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add(Checkbox::new(&mut obj.lon, "Left"));
});
row.col(|ui| {
ui.add(Checkbox::new(&mut obj.ron, "Right"));
});
});
});
if obj.update(&mut object) {
let address = 0x3e000 + self.index * 8;
self.memory.write(self.sim_id, address as u32, &object);
}
});
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.generic_palette, "Generic palette");
});
});
self.params.write(ObjectParams {
index: self.index,
generic_palette: self.generic_palette,
..*self.params
});
}
fn show_object(&mut self, ui: &mut Ui) {
let image = Image::new("vip://full")
.fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST);
ui.add(image);
}
}
impl AppWindow for ObjectWindow {
fn viewport_id(&self) -> egui::ViewportId {
ViewportId::from_hash_of(format!("object-{}", self.sim_id))
}
fn sim_id(&self) -> SimId {
self.sim_id
}
fn initial_viewport(&self) -> ViewportBuilder {
ViewportBuilder::default()
.with_title(format!("Object Data ({})", self.sim_id))
.with_inner_size((640.0, 500.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) {
CentralPanel::default().show(ctx, |ui| {
ui.horizontal_top(|ui| {
StripBuilder::new(ui)
.size(Size::relative(0.3).at_most(200.0))
.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_object(ui));
});
});
});
});
}
}
#[derive(Clone, PartialEq, Eq)]
struct ObjectParams {
index: usize,
generic_palette: bool,
left_color: Color32,
right_color: Color32,
}
enum Eye {
Left,
Right,
}
struct ObjectRenderer {
chardata: MemoryView,
objects: MemoryView,
brightness: MemoryView,
palettes: MemoryView,
}
impl ObjectRenderer {
pub fn new(sim_id: SimId, memory: &MemoryClient) -> Self {
Self {
chardata: memory.watch(sim_id, 0x00078000, 0x8000),
objects: memory.watch(sim_id, 0x0003e000, 0x2000),
brightness: memory.watch(sim_id, 0x0005f824, 8),
palettes: memory.watch(sim_id, 0x0005f860, 16),
}
}
fn render_object(
&self,
image: &mut ImageBuffer,
params: &ObjectParams,
use_pos: bool,
eye: Eye,
) {
let chardata = self.chardata.borrow();
let objects = self.objects.borrow();
let brightness = self.brightness.borrow();
let palettes = self.palettes.borrow();
let object: [u16; 4] = objects.read(params.index);
let obj = Object::parse(object);
if match eye {
Eye::Left => !obj.lon,
Eye::Right => !obj.ron,
} {
return;
}
let brts = brightness.read::<[u8; 8]>(0);
let (x, y) = if use_pos {
let x = match eye {
Eye::Left => obj.x - obj.parallax,
Eye::Right => obj.x + obj.parallax,
};
(x, obj.y)
} else {
(0, 0)
};
let color = match eye {
Eye::Left => params.left_color,
Eye::Right => params.right_color,
};
let char = chardata.read::<[u16; 8]>(obj.data.char_index);
let palette = if params.generic_palette {
utils::generic_palette(color)
} else {
utils::palette_colors(palettes.read(8 + obj.data.palette_index * 2), &brts, color)
};
for row in 0..8 {
let real_y = y + row as i16;
if !(0..224).contains(&real_y) {
continue;
}
for (col, pixel) in
utils::read_char_row(&char, obj.data.hflip, obj.data.vflip, row).enumerate()
{
let real_x = x + col as i16;
if !(0..384).contains(&real_x) {
continue;
}
image.add((real_x as usize, real_y as usize), palette[pixel as usize]);
}
}
}
}
impl ImageRenderer<2> for ObjectRenderer {
type Params = ObjectParams;
fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [384, 224]]
}
fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 2]) {
images[0].clear();
self.render_object(&mut images[0], params, false, Eye::Left);
self.render_object(&mut images[0], params, false, Eye::Right);
images[1].clear();
self.render_object(&mut images[1], params, true, Eye::Left);
self.render_object(&mut images[1], params, true, Eye::Right);
}
}
src/window/vip/registers.rs
+819
View File
@@ -0,0 +1,819 @@
use std::sync::Arc;
use egui::{
Align, Button, CentralPanel, Checkbox, Color32, Context, Direction, Label, Layout, ScrollArea,
TextEdit, Ui, ViewportBuilder, ViewportId,
};
use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{
emulator::SimId,
memory::{MemoryClient, MemoryRef, MemoryValue, MemoryView},
window::{
utils::{NumberEdit, UiExt},
AppWindow,
},
};
use super::utils;
pub struct RegisterWindow {
sim_id: SimId,
memory: Arc<MemoryClient>,
registers: MemoryView,
}
impl RegisterWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>) -> Self {
Self {
sim_id,
memory: memory.clone(),
registers: memory.watch(sim_id, 0x0005f800, 0x72),
}
}
fn show_interrupts(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
let [mut raw_intpnd, mut raw_intenb] = self.read_address(0x0005f800);
let mut intenb = InterruptReg::parse(raw_intenb);
let mut intpnd = InterruptReg::parse(raw_intpnd);
ui.section("Interrupt", |ui| {
let width = ui.available_width();
let xspace = ui.spacing().item_spacing.x;
ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
TableBuilder::new(ui)
.id_salt("raw_values")
.columns(Column::exact(width * 0.5 - xspace), 2)
.cell_layout(Layout::left_to_right(Align::Max))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("INTENB");
});
row.col(|ui| {
let mut text = format!("{raw_intenb:04x}");
ui.add_sized(
ui.available_size(),
TextEdit::singleline(&mut text).horizontal_align(Align::Max),
);
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("INTPND");
});
row.col(|ui| {
let mut text = format!("{raw_intpnd:04x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut text).horizontal_align(Align::Max),
);
});
});
});
ui.add_space(8.0);
TableBuilder::new(ui)
.id_salt("flags")
.column(Column::exact(width * 0.5 - xspace))
.columns(Column::exact(width * 0.25 - xspace), 2)
.cell_layout(Layout::left_to_right(Align::Center).with_main_align(Align::RIGHT))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|_ui| {});
row.col(|ui| {
ui.add_sized(ui.available_size(), Label::new("ENB"));
});
row.col(|ui| {
ui.add_sized(ui.available_size(), Label::new("PND"));
});
});
let mut add_row = |label: &str, enb: &mut bool, pnd: &mut bool| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label(label);
});
row.col(|ui| {
let space =
(ui.available_width() - ui.spacing().icon_width) / 2.0;
ui.add_space(space);
ui.checkbox(enb, "");
});
row.col(|ui| {
let space =
(ui.available_width() - ui.spacing().icon_width) / 2.0;
ui.add_space(space);
ui.checkbox(pnd, "");
});
});
};
add_row("TIMEERR", &mut intenb.timeerr, &mut intpnd.timeerr);
add_row("XPEND", &mut intenb.xpend, &mut intpnd.xpend);
add_row("SBHIT", &mut intenb.sbhit, &mut intpnd.sbhit);
add_row("FRAMESTART", &mut intenb.framestart, &mut intpnd.framestart);
add_row("GAMESTART", &mut intenb.gamestart, &mut intpnd.gamestart);
add_row("RFBEND", &mut intenb.rfbend, &mut intpnd.rfbend);
add_row("LFBEND", &mut intenb.lfbend, &mut intpnd.lfbend);
add_row("SCANERR", &mut intenb.scanerr, &mut intpnd.scanerr);
});
});
ui.allocate_space(ui.available_size());
});
if intpnd.update(&mut raw_intpnd) {
self.memory.write(self.sim_id, 0x0005f800, &raw_intpnd);
}
if intenb.update(&mut raw_intenb) {
self.memory.write(self.sim_id, 0x0005f802, &raw_intenb);
}
}
fn show_display_status(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
let mut raw_dpstts = self.read_address(0x0005f820);
let mut dpstts = DisplayReg::parse(raw_dpstts);
ui.section("Display", |ui| {
let width = ui.available_width();
TableBuilder::new(ui)
.column(Column::exact(width * 0.5))
.column(Column::exact(width * 0.5))
.cell_layout(Layout::left_to_right(Align::Max))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("DPSTTS");
});
row.col(|ui| {
let mut value_str = format!("{raw_dpstts:04x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut value_str).horizontal_align(Align::Max),
);
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(true, Checkbox::new(&mut dpstts.lock, "LOCK"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.r1bsy, "R1BSY"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(true, Checkbox::new(&mut dpstts.synce, "SYNCE"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.l1bsy, "L1BSY"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(true, Checkbox::new(&mut dpstts.re, "RE"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.r0bsy, "R0BSY"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.fclk, "FCLK"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.l0bsy, "L0BSY"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut dpstts.scanrdy, "SCANRDY"));
});
row.col(|ui| {
ui.add_enabled(true, Checkbox::new(&mut dpstts.disp, "DISP"));
});
});
body.row(row_height, |mut row| {
row.col(|_ui| {});
row.col(|ui| {
if ui
.add(Button::new("DPRST").min_size(ui.available_size()))
.clicked()
{
dpstts.dprst = true;
}
});
});
});
ui.allocate_space(ui.available_size());
});
if dpstts.update(&mut raw_dpstts) {
self.memory.write(self.sim_id, 0x0005f822, &raw_dpstts);
}
}
fn show_drawing_status(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
let [mut raw_xpstts, raw_xpctrl] = self.read_address(0x0005f840);
let mut xpstts = DrawingReg::parse(raw_xpstts);
ui.section("Drawing", |ui| {
let width = ui.available_width();
TableBuilder::new(ui)
.column(Column::exact(width * 0.5))
.column(Column::exact(width * 0.5))
.cell_layout(Layout::left_to_right(Align::Max))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("XPCTRL");
});
row.col(|ui| {
let mut value_str = format!("{raw_xpctrl:04x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut value_str).horizontal_align(Align::Max),
);
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("XPSTTS");
});
row.col(|ui| {
let mut value_str = format!("{raw_xpstts:04x}");
ui.add_enabled(
false,
TextEdit::singleline(&mut value_str).horizontal_align(Align::Max),
);
});
});
/*
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("SBCMP");
});
row.col(|ui| {
let old_value = xpctrl.sbcmp;
ui.add_enabled(true, NumberEdit::new(&mut xpctrl.sbcmp).range(0..32));
cmp_changed = xpctrl.sbcmp != old_value;
});
});
*/
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("SBCOUNT");
});
row.col(|ui| {
ui.add_enabled(
false,
NumberEdit::new(&mut xpstts.sbcount)
.arrows(false)
.range(0..32),
);
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut xpstts.sbout, "SBOUT"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut xpstts.f1bsy, "F1BSY"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut xpstts.f0bsy, "F0BSY"));
});
row.col(|ui| {
ui.add_enabled(false, Checkbox::new(&mut xpstts.overtime, "OVERTIME"));
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.add_enabled(true, Checkbox::new(&mut xpstts.xpen, "XPEN"));
});
row.col(|ui| {
if ui
.add(Button::new("XPRST").min_size(ui.available_size()))
.clicked()
{
xpstts.xprst = true;
}
});
});
});
ui.allocate_space(ui.available_size());
});
if xpstts.update(&mut raw_xpstts) {
xpstts.update(&mut raw_xpstts);
self.memory.write(self.sim_id, 0x0005f842, &raw_xpstts);
}
}
fn show_colors(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
let registers = self.registers.borrow();
ui.section("Colors", |ui| {
let width = ui.available_width();
let xspace = ui.spacing().item_spacing.x;
TableBuilder::new(ui)
.column(Column::exact(width * 0.2 - xspace))
.columns(Column::exact(width * 0.20 - xspace), 4)
.cell_layout(Layout::left_to_right(Align::Max))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|_ui| {});
row.col(|_ui| {});
row.col(|ui| {
ui.with_layout(
Layout::centered_and_justified(Direction::LeftToRight),
|ui| ui.label("1"),
);
});
row.col(|ui| {
ui.with_layout(
Layout::centered_and_justified(Direction::LeftToRight),
|ui| ui.label("2"),
);
});
row.col(|ui| {
ui.with_layout(
Layout::centered_and_justified(Direction::LeftToRight),
|ui| ui.label("3"),
);
});
});
let mut brts: [u16; 3] = [
read_address(&registers, 0x0005f824),
read_address(&registers, 0x0005f826),
read_address(&registers, 0x0005f828),
];
body.row(row_height, |mut row| {
let mut stale = false;
row.col(|ui| {
ui.label("BRT");
});
row.col(|_ui| {});
for brt in brts.iter_mut() {
row.col(|ui| {
if ui
.add(NumberEdit::new(brt).range(0..256).arrows(false).hex(true))
.changed()
{
stale = true;
}
});
}
if stale {
self.memory.write(self.sim_id, 0x0005f824, &brts);
}
});
body.row(row_height, |mut row| {
row.col(|_ui| {});
for shade in utils::parse_brts(&brts, Color32::RED) {
row.col(|ui| {
ui.painter().rect_filled(
ui.available_rect_before_wrap(),
0.0,
shade,
);
});
}
});
let mut palettes = read_address::<[u16; 8]>(&registers, 0x0005f860);
let mut add_row = |name: &str, address: u32, value: &mut u16| {
let mut c1 = (*value >> 2) & 0x03;
let mut c2 = (*value >> 4) & 0x03;
let mut c3 = (*value >> 6) & 0x03;
let mut stale = false;
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label(name);
});
row.col(|ui| {
if ui
.add(
NumberEdit::new(value)
.range(0..256)
.desired_width(width * 0.2)
.arrows(false)
.hex(true),
)
.changed()
{
stale = true;
};
});
row.col(|ui| {
if ui
.add(
NumberEdit::new(&mut c1)
.range(0..4)
.desired_width(ui.available_width() - xspace),
)
.changed()
{
*value = (*value & 0xfff3) | (c1 << 2);
stale = true;
}
});
row.col(|ui| {
if ui
.add(
NumberEdit::new(&mut c2)
.range(0..4)
.desired_width(ui.available_width() - xspace),
)
.changed()
{
*value = (*value & 0xffcf) | (c2 << 4);
stale = true;
}
});
row.col(|ui| {
if ui
.add(
NumberEdit::new(&mut c3)
.range(0..4)
.desired_width(ui.available_width() - xspace),
)
.changed()
{
*value = (*value & 0xff3f) | (c3 << 6);
stale = true;
}
});
});
if stale {
self.memory.write(self.sim_id, address, value);
}
};
add_row("GPLT0", 0x0005f860, &mut palettes[0]);
add_row("GPLT1", 0x0005f862, &mut palettes[1]);
add_row("GPLT2", 0x0005f864, &mut palettes[2]);
add_row("GPLT3", 0x0005f866, &mut palettes[3]);
add_row("JPLT0", 0x0005f868, &mut palettes[4]);
add_row("JPLT1", 0x0005f86a, &mut palettes[5]);
add_row("JPLT2", 0x0005f86c, &mut palettes[6]);
add_row("JPLT3", 0x0005f86e, &mut palettes[7]);
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("BKCOL");
});
row.col(|ui| {
let mut bkcol: u16 = read_address(&registers, 0x0005f870);
if ui
.add(
NumberEdit::new(&mut bkcol)
.range(0..4)
.desired_width(ui.available_width() - xspace),
)
.changed()
{
self.memory.write(self.sim_id, 0x0005f870, &bkcol);
}
});
row.col(|_ui| {});
row.col(|ui| {
ui.label("REST");
});
row.col(|ui| {
let mut rest: u16 = read_address(&registers, 0x0005f82a);
if ui
.add(
NumberEdit::new(&mut rest)
.range(0..256)
.arrows(false)
.hex(true),
)
.changed()
{
self.memory.write(self.sim_id, 0x0005f82a, &rest);
}
});
});
});
ui.allocate_space(ui.available_size_before_wrap());
});
}
fn show_objects(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
ui.section("Objects", |ui| {
let width = ui.available_width();
let xspace = ui.spacing().item_spacing.x;
TableBuilder::new(ui)
.column(Column::exact(width * 0.3 - xspace))
.column(Column::exact(width * 0.3 - xspace))
.column(Column::exact(width * 0.4 - xspace))
.cell_layout(Layout::left_to_right(Align::Center).with_main_align(Align::RIGHT))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|_ui| {});
row.col(|ui| {
ui.add_sized(ui.available_size(), Label::new("Start"));
});
row.col(|ui| {
ui.add_sized(ui.available_size(), Label::new("End"));
});
});
let mut spts = self.read_address::<[u16; 4]>(0x0005f848);
let prevs = std::iter::once(0u16).chain(spts.map(|i| (i + 1) & 0x03ff));
let mut changed = false;
for (index, (spt, prev)) in spts.iter_mut().zip(prevs).enumerate() {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label(format!("SPT{index}"));
});
row.col(|ui| {
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
ui.label(prev.to_string());
});
});
row.col(|ui| {
if ui.add(NumberEdit::new(spt).range(0..1024)).changed() {
changed = true;
}
});
});
}
if changed {
self.memory.write(self.sim_id, 0x0005f848, &spts);
}
});
ui.allocate_space(ui.available_size_before_wrap());
});
}
fn show_misc(&mut self, ui: &mut Ui) {
let row_height = self.row_height(ui);
let registers = self.registers.borrow();
ui.section("Misc.", |ui| {
let width = ui.available_width();
let xspace = ui.spacing().item_spacing.x;
TableBuilder::new(ui)
.column(Column::exact(width * 0.5 - xspace))
.column(Column::exact(width * 0.5 - xspace))
.cell_layout(Layout::left_to_right(Align::Center).with_main_align(Align::RIGHT))
.body(|mut body| {
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("FRMCYC");
});
row.col(|ui| {
let mut frmcyc = read_address::<u16>(&registers, 0x0005f82e);
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
if ui.add(NumberEdit::new(&mut frmcyc).range(0..32)).changed() {
self.memory.write(self.sim_id, 0x0005f82e, &frmcyc);
}
});
});
});
let mut cta = read_address::<u16>(&registers, 0x0005f830);
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("CTA");
});
row.col(|ui| {
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
ui.add_enabled(
false,
NumberEdit::new(&mut cta).arrows(false).hex(true),
);
});
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("CTA_L");
});
row.col(|ui| {
let mut cta_l = cta & 0xff;
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
ui.add_enabled(
false,
NumberEdit::new(&mut cta_l).arrows(false).hex(true),
);
});
});
});
body.row(row_height, |mut row| {
row.col(|ui| {
ui.label("CTA_R");
});
row.col(|ui| {
let mut cta_r = (cta >> 8) & 0xff;
ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
ui.add_enabled(
false,
NumberEdit::new(&mut cta_r).arrows(false).hex(true),
);
});
});
});
});
ui.allocate_space(ui.available_size_before_wrap());
});
}
fn row_height(&self, ui: &mut Ui) -> f32 {
ui.spacing().interact_size.y + ui.style().visuals.selection.stroke.width
}
fn read_address<T: MemoryValue>(&self, address: usize) -> T {
read_address(&self.registers.borrow(), address)
}
}
fn read_address<T: MemoryValue>(registers: &MemoryRef, address: usize) -> T {
let index = (address - 0x0005f800) / size_of::<T>();
registers.read(index)
}
impl AppWindow for RegisterWindow {
fn viewport_id(&self) -> ViewportId {
ViewportId::from_hash_of(format!("registers-{}", self.sim_id))
}
fn sim_id(&self) -> SimId {
self.sim_id
}
fn initial_viewport(&self) -> ViewportBuilder {
ViewportBuilder::default()
.with_title(format!("Registers ({})", self.sim_id))
.with_inner_size((800.0, 480.0))
}
fn show(&mut self, ctx: &Context) {
CentralPanel::default().show(ctx, |ui| {
ScrollArea::vertical().show(ui, |ui| {
ui.horizontal_top(|ui| {
let width = ui.available_width();
let xspace = ui.spacing().item_spacing.x;
StripBuilder::new(ui)
.size(Size::exact(width * 0.25 - xspace))
.size(Size::exact(width * 0.225 - xspace))
.size(Size::exact(width * 0.325 - xspace))
.size(Size::exact(width * 0.2 - xspace))
.horizontal(|mut strip| {
strip.cell(|ui| {
self.show_interrupts(ui);
});
strip.strip(|nested| {
nested.sizes(Size::remainder(), 2).vertical(|mut strip| {
strip.cell(|ui| {
self.show_display_status(ui);
});
strip.cell(|ui| {
self.show_drawing_status(ui);
});
});
});
strip.cell(|ui| {
self.show_colors(ui);
});
strip.strip(|nested| {
nested.sizes(Size::remainder(), 2).vertical(|mut strip| {
strip.cell(|ui| {
self.show_objects(ui);
});
strip.cell(|ui| {
self.show_misc(ui);
});
});
});
});
});
});
});
}
}
struct InterruptReg {
timeerr: bool,
xpend: bool,
sbhit: bool,
framestart: bool,
gamestart: bool,
rfbend: bool,
lfbend: bool,
scanerr: bool,
}
impl InterruptReg {
fn parse(value: u16) -> Self {
Self {
timeerr: value & 0x8000 != 0,
xpend: value & 0x4000 != 0,
sbhit: value & 0x2000 != 0,
framestart: value & 0x0010 != 0,
gamestart: value & 0x0008 != 0,
rfbend: value & 0x0004 != 0,
lfbend: value & 0x0002 != 0,
scanerr: value & 0x0001 != 0,
}
}
fn update(&self, value: &mut u16) -> bool {
let new_value = (*value & 0x1fe0)
| if self.timeerr { 0x8000 } else { 0x0000 }
| if self.xpend { 0x4000 } else { 0x0000 }
| if self.sbhit { 0x2000 } else { 0x0000 }
| if self.framestart { 0x0010 } else { 0x0000 }
| if self.gamestart { 0x0008 } else { 0x0000 }
| if self.rfbend { 0x0004 } else { 0x0000 }
| if self.lfbend { 0x0002 } else { 0x0000 }
| if self.scanerr { 0x0001 } else { 0x0000 };
let changed = *value != new_value;
*value = new_value;
changed
}
}
struct DisplayReg {
lock: bool,
synce: bool,
re: bool,
fclk: bool,
scanrdy: bool,
r1bsy: bool,
l1bsy: bool,
r0bsy: bool,
l0bsy: bool,
disp: bool,
dprst: bool,
}
impl DisplayReg {
fn parse(value: u16) -> Self {
Self {
lock: value & 0x0400 != 0,
synce: value & 0x0200 != 0,
re: value & 0x0100 != 0,
fclk: value & 0x0080 != 0,
scanrdy: value & 0x0040 != 0,
r1bsy: value & 0x0020 != 0,
l1bsy: value & 0x0010 != 0,
r0bsy: value & 0x0008 != 0,
l0bsy: value & 0x0004 != 0,
disp: value & 0x0002 != 0,
dprst: value & 0x0001 != 0,
}
}
fn update(&self, value: &mut u16) -> bool {
let new_value = (*value & 0xf800)
| if self.lock { 0x0400 } else { 0x0000 }
| if self.synce { 0x0200 } else { 0x0000 }
| if self.re { 0x0100 } else { 0x0000 }
| if self.fclk { 0x0080 } else { 0x0000 }
| if self.scanrdy { 0x0040 } else { 0x0000 }
| if self.r1bsy { 0x0020 } else { 0x0000 }
| if self.l1bsy { 0x0010 } else { 0x0000 }
| if self.r0bsy { 0x0008 } else { 0x0000 }
| if self.l0bsy { 0x0004 } else { 0x0000 }
| if self.disp { 0x0002 } else { 0x0000 }
| if self.dprst { 0x0001 } else { 0x0000 };
let changed = *value != new_value;
*value = new_value;
changed
}
}
struct DrawingReg {
sbout: bool,
sbcount: u8,
overtime: bool,
f1bsy: bool,
f0bsy: bool,
xpen: bool,
xprst: bool,
}
impl DrawingReg {
fn parse(value: u16) -> Self {
Self {
sbout: value & 0x8000 != 0,
sbcount: (value >> 8) as u8 & 0x1f,
overtime: value & 0x0010 != 0,
f1bsy: value & 0x0008 != 0,
f0bsy: value & 0x0004 != 0,
xpen: value & 0x0002 != 0,
xprst: value & 0x0001 != 0,
}
}
fn update(&self, value: &mut u16) -> bool {
let new_value = (*value & 0x60e0)
| if self.sbout { 0x8000 } else { 0x0000 }
| (((self.sbcount & 0x1f) as u16) << 8)
| if self.overtime { 0x0010 } else { 0x0000 }
| if self.f1bsy { 0x0008 } else { 0x0000 }
| if self.f0bsy { 0x0004 } else { 0x0000 }
| if self.xpen { 0x0002 } else { 0x0000 }
| if self.xprst { 0x0001 } else { 0x0000 };
let changed = *value != new_value;
*value = new_value;
changed
}
}
src/window/vip/utils.rs
+251
View File
@@ -0,0 +1,251 @@
use egui::{Color32, Image, ImageSource, Response, Sense, TextureOptions, Ui, Widget};
pub const GENERIC_PALETTE: [u8; 4] = [0, 32, 64, 128];
pub fn shade(brt: u8, color: Color32) -> Color32 {
let corrected = if brt & 0x80 != 0 {
255
} else {
(brt << 1) | (brt >> 6)
};
color.gamma_multiply(corrected as f32 / 255.0)
}
pub fn generic_palette(color: Color32) -> [Color32; 4] {
GENERIC_PALETTE.map(|brt| shade(brt, color))
}
pub const fn parse_palette(palette: u8) -> [u8; 4] {
[
0,
(palette >> 2) & 0x03,
(palette >> 4) & 0x03,
(palette >> 6) & 0x03,
]
}
pub const fn parse_shades(brts: &[u8; 8]) -> [u8; 4] {
[
0,
brts[0],
brts[2],
brts[0].saturating_add(brts[2]).saturating_add(brts[4]),
]
}
pub fn parse_brts(brts: &[u16; 3], color: Color32) -> [Color32; 4] {
[
Color32::BLACK,
shade(brts[0] as u8, color),
shade(brts[1] as u8, color),
shade((brts[0] + brts[1] + brts[2]) as u8, color),
]
}
pub fn palette_colors(palette: u8, brts: &[u8; 8], color: Color32) -> [Color32; 4] {
let colors = parse_shades(brts).map(|s| shade(s, color));
parse_palette(palette).map(|p| colors[p as usize])
}
pub struct Object {
pub x: i16,
pub lon: bool,
pub ron: bool,
pub parallax: i16,
pub y: i16,
pub data: CellData,
}
impl Object {
pub fn parse(object: [u16; 4]) -> Self {
let x = ((object[0] & 0x03ff) << 6 >> 6) as i16;
let parallax = ((object[1] & 0x03ff) << 6 >> 6) as i16;
let lon = object[1] & 0x8000 != 0;
let ron = object[1] & 0x4000 != 0;
let y = (object[2] & 0x00ff) as i16;
// Y is stored as the bottom 8 bits of an i16,
// so only sign extend if it's out of range.
let y = if y > 224 { y << 8 >> 8 } else { y };
let data = CellData::parse(object[3]);
Self {
x,
lon,
ron,
parallax,
y,
data,
}
}
pub fn update(&self, source: &mut [u16; 4]) -> bool {
let mut changed = false;
let new_x = (self.x as u16 & 0x03ff) | (source[0] & 0xfc00);
changed |= source[0] != new_x;
source[0] = new_x;
let new_p = if self.lon { 0x8000 } else { 0x0000 }
| if self.ron { 0x4000 } else { 0x0000 }
| (self.parallax as u16 & 0x3ff)
| (source[1] & 0x3c00);
changed |= source[1] != new_p;
source[1] = new_p;
let new_y = (self.y as u16 & 0x00ff) | (source[2] & 0xff00);
changed |= source[2] != new_y;
source[2] = new_y;
if self.data.update(&mut source[3]) {
changed = true;
}
changed
}
}
pub struct CellData {
pub palette_index: usize,
pub hflip: bool,
pub vflip: bool,
pub char_index: usize,
}
impl CellData {
pub fn parse(cell: u16) -> Self {
let char_index = (cell & 0x7ff) as usize;
let vflip = cell & 0x1000 != 0;
let hflip = cell & 0x2000 != 0;
let palette_index = (cell >> 14) as usize;
Self {
char_index,
vflip,
hflip,
palette_index,
}
}
pub fn update(&self, source: &mut u16) -> bool {
let new_value = (self.palette_index as u16) << 14
| if self.hflip { 0x2000 } else { 0x0000 }
| if self.vflip { 0x1000 } else { 0x0000 }
| (self.char_index as u16 & 0x07ff)
| (*source & 0x0800);
let changed = *source != new_value;
*source = new_value;
changed
}
}
pub fn read_char_row(
char: &[u16; 8],
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
})
}
pub fn read_char_pixel(char: &[u16; 8], hflip: bool, vflip: bool, row: usize, col: usize) -> u8 {
let pixels = if vflip { char[7 - row] } else { char[row] };
let pixel = if hflip { 7 - col } else { col } << 1;
((pixels >> pixel) & 0x3) as u8
}
pub struct CharacterGrid<'a> {
source: ImageSource<'a>,
scale: f32,
show_grid: bool,
selected: Option<usize>,
}
impl<'a> CharacterGrid<'a> {
pub fn new(source: impl Into<ImageSource<'a>>) -> Self {
Self {
source: source.into(),
scale: 1.0,
show_grid: false,
selected: None,
}
}
pub fn with_scale(self, scale: f32) -> Self {
Self { scale, ..self }
}
pub fn with_grid(self, show_grid: bool) -> Self {
Self { show_grid, ..self }
}
pub fn with_selected(self, selected: usize) -> Self {
Self {
selected: Some(selected),
..self
}
}
pub fn show(self, ui: &mut Ui) -> Option<usize> {
let start_pos = ui.cursor().min;
let cell_size = 8.0 * self.scale;
let res = self.ui(ui);
let grid_width_cells = ((res.rect.max.x - res.rect.min.x) / cell_size).round() as usize;
if res.clicked() {
let click_pos = res.interact_pointer_pos()?;
let grid_pos = (click_pos - start_pos) / cell_size;
Some((grid_pos.y as usize * grid_width_cells) + grid_pos.x as usize)
} else {
None
}
}
}
impl Widget for CharacterGrid<'_> {
fn ui(self, ui: &mut Ui) -> Response {
let image = Image::new(self.source)
.fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST)
.sense(Sense::click());
let res = ui.add(image);
let cell_size = 8.0 * self.scale;
let grid_width_cells = ((res.rect.max.x - res.rect.min.x) / cell_size).round() as usize;
let grid_height_cells = ((res.rect.max.y - res.rect.min.y) / cell_size).round() as usize;
let painter = ui.painter_at(res.rect);
if self.show_grid {
let stroke = ui.style().visuals.widgets.noninteractive.fg_stroke;
for x in (1..grid_width_cells).map(|i| (i as f32) * cell_size) {
let p1 = (res.rect.min.x + x, res.rect.min.y).into();
let p2 = (res.rect.min.x + x, res.rect.max.y).into();
painter.line(vec![p1, p2], stroke);
}
for y in (1..grid_height_cells).map(|i| (i as f32) * cell_size) {
let p1 = (res.rect.min.x, res.rect.min.y + y).into();
let p2 = (res.rect.max.x, res.rect.min.y + y).into();
painter.line(vec![p1, p2], stroke);
}
}
if let Some(selected) = self.selected {
let x1 = (selected % grid_width_cells) as f32 * cell_size;
let x2 = x1 + cell_size;
let y1 = (selected / grid_width_cells) as f32 * cell_size;
let y2 = y1 + cell_size;
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,
);
}
res
}
}
src/window/vip/world.rs
+1132
View File
File diff suppressed because it is too large Load Diff