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

VIP inspection tooling #4

Merged
SonicSwordcane merged 34 commits from vram into main 2025-02-24 04:01:18 +00:00
Conversation 0 Commits 34 Files Changed 20 +125 -119
13 changed files with 125 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 6ab9d2ee53 - Show all commits

20
src/app.rs
View File

@ -17,10 +17,10 @@ use winit::{
use crate::{ use crate::{
controller::ControllerManager, controller::ControllerManager,
emulator::{EmulatorClient, EmulatorCommand, SimId}, emulator::{EmulatorClient, EmulatorCommand, SimId},
images::ImageProcessor,
input::MappingProvider, input::MappingProvider,
memory::MemoryClient, memory::MemoryClient,
persistence::Persistence, persistence::Persistence,
vram::VramProcessor,
window::{ window::{
AboutWindow, AppWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, GameWindow, AboutWindow, AppWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, GameWindow,
GdbServerWindow, InputWindow, ObjectWindow, RegisterWindow, WorldWindow, GdbServerWindow, InputWindow, ObjectWindow, RegisterWindow, WorldWindow,
@ -46,7 +46,7 @@ pub struct Application {
mappings: MappingProvider, mappings: MappingProvider,
controllers: ControllerManager, controllers: ControllerManager,
memory: Arc<MemoryClient>, memory: Arc<MemoryClient>,
vram: VramProcessor, images: ImageProcessor,
persistence: Persistence, persistence: Persistence,
viewports: HashMap<ViewportId, Viewport>, viewports: HashMap<ViewportId, Viewport>,
focused: Option<ViewportId>, focused: Option<ViewportId>,
@ -65,7 +65,7 @@ impl Application {
let mappings = MappingProvider::new(persistence.clone()); let mappings = MappingProvider::new(persistence.clone());
let controllers = ControllerManager::new(client.clone(), &mappings); let controllers = ControllerManager::new(client.clone(), &mappings);
let memory = Arc::new(MemoryClient::new(client.clone())); let memory = Arc::new(MemoryClient::new(client.clone()));
let vram = VramProcessor::new(); let images = ImageProcessor::new();
{ {
let mappings = mappings.clone(); let mappings = mappings.clone();
let proxy = proxy.clone(); let proxy = proxy.clone();
@ -78,7 +78,7 @@ impl Application {
proxy, proxy,
mappings, mappings,
memory, memory,
vram, images,
controllers, controllers,
persistence, persistence,
viewports: HashMap::new(), viewports: HashMap::new(),
@ -214,23 +214,23 @@ impl ApplicationHandler<UserEvent> for Application {
self.open(event_loop, Box::new(about)); self.open(event_loop, Box::new(about));
} }
UserEvent::OpenCharacterData(sim_id) => { UserEvent::OpenCharacterData(sim_id) => {
let vram = CharacterDataWindow::new(sim_id, &self.memory, &mut self.vram); let chardata = CharacterDataWindow::new(sim_id, &self.memory, &mut self.images);
self.open(event_loop, Box::new(vram)); self.open(event_loop, Box::new(chardata));
} }
UserEvent::OpenBgMap(sim_id) => { UserEvent::OpenBgMap(sim_id) => {
let bgmap = BgMapWindow::new(sim_id, &self.memory, &mut self.vram); let bgmap = BgMapWindow::new(sim_id, &self.memory, &mut self.images);
self.open(event_loop, Box::new(bgmap)); self.open(event_loop, Box::new(bgmap));
} }
UserEvent::OpenObjects(sim_id) => { UserEvent::OpenObjects(sim_id) => {
let objects = ObjectWindow::new(sim_id, &self.memory, &mut self.vram); let objects = ObjectWindow::new(sim_id, &self.memory, &mut self.images);
self.open(event_loop, Box::new(objects)); self.open(event_loop, Box::new(objects));
} }
UserEvent::OpenWorlds(sim_id) => { UserEvent::OpenWorlds(sim_id) => {
let world = WorldWindow::new(sim_id, &self.memory, &mut self.vram); let world = WorldWindow::new(sim_id, &self.memory, &mut self.images);
self.open(event_loop, Box::new(world)); self.open(event_loop, Box::new(world));
} }
UserEvent::OpenFrameBuffers(sim_id) => { UserEvent::OpenFrameBuffers(sim_id) => {
let world = FrameBufferWindow::new(sim_id, &self.memory, &mut self.vram); let world = FrameBufferWindow::new(sim_id, &self.memory, &mut self.images);
self.open(event_loop, Box::new(world)); self.open(event_loop, Box::new(world));
} }
UserEvent::OpenRegisters(sim_id) => { UserEvent::OpenRegisters(sim_id) => {

76
src/vram.rs → src/images.rs
View File

@ -13,11 +13,11 @@ use egui::{
}; };
use tokio::{sync::mpsc, time::timeout}; use tokio::{sync::mpsc, time::timeout};
pub struct VramProcessor { pub struct ImageProcessor {
sender: mpsc::UnboundedSender<Box<dyn VramRendererImpl>>, sender: mpsc::UnboundedSender<Box<dyn ImageRendererImpl>>,
} }
impl VramProcessor { impl ImageProcessor {
pub fn new() -> Self { pub fn new() -> Self {
let (sender, receiver) = mpsc::unbounded_channel(); let (sender, receiver) = mpsc::unbounded_channel();
thread::spawn(move || { thread::spawn(move || {
@ -26,7 +26,7 @@ impl VramProcessor {
.build() .build()
.unwrap() .unwrap()
.block_on(async move { .block_on(async move {
let mut worker = VramProcessorWorker { let mut worker = ImageProcessorWorker {
receiver, receiver,
renderers: vec![], renderers: vec![],
}; };
@ -36,27 +36,27 @@ impl VramProcessor {
Self { sender } Self { sender }
} }
pub fn add<const N: usize, R: VramRenderer<N> + 'static>( pub fn add<const N: usize, R: ImageRenderer<N> + 'static>(
&self, &self,
renderer: R, renderer: R,
params: R::Params, params: R::Params,
) -> ([VramImageHandle; N], VramParams<R::Params>) { ) -> ([ImageHandle; N], ImageParams<R::Params>) {
let states = renderer.sizes().map(VramRenderImageState::new); let states = renderer.sizes().map(ImageState::new);
let handles = states.clone().map(|state| VramImageHandle { let handles = states.clone().map(|state| ImageHandle {
size: state.size.map(|i| i as f32), size: state.size.map(|i| i as f32),
data: state.sink, data: state.sink,
}); });
let images = renderer let images = renderer
.sizes() .sizes()
.map(|[width, height]| VramImage::new(width, height)); .map(|[width, height]| ImageBuffer::new(width, height));
let sink = Arc::new(Mutex::new(params.clone())); let sink = Arc::new(Mutex::new(params.clone()));
let _ = self.sender.send(Box::new(VramRendererWrapper { let _ = self.sender.send(Box::new(ImageRendererWrapper {
renderer, renderer,
params: Arc::downgrade(&sink), params: Arc::downgrade(&sink),
images, images,
states, states,
})); }));
let params = VramParams { let params = ImageParams {
value: params, value: params,
sink, sink,
}; };
@ -64,12 +64,12 @@ impl VramProcessor {
} }
} }
struct VramProcessorWorker { struct ImageProcessorWorker {
receiver: mpsc::UnboundedReceiver<Box<dyn VramRendererImpl>>, receiver: mpsc::UnboundedReceiver<Box<dyn ImageRendererImpl>>,
renderers: Vec<Box<dyn VramRendererImpl>>, renderers: Vec<Box<dyn ImageRendererImpl>>,
} }
impl VramProcessorWorker { impl ImageProcessorWorker {
async fn run(&mut self) { async fn run(&mut self) {
loop { loop {
if self.renderers.is_empty() { if self.renderers.is_empty() {
@ -100,12 +100,12 @@ impl VramProcessorWorker {
} }
} }
pub struct VramImage { pub struct ImageBuffer {
pub size: [usize; 2], pub size: [usize; 2],
pub pixels: Vec<Color32>, pub pixels: Vec<Color32>,
} }
impl VramImage { impl ImageBuffer {
pub fn new(width: usize, height: usize) -> Self { pub fn new(width: usize, height: usize) -> Self {
Self { Self {
size: [width, height], size: [width, height],
@ -143,23 +143,23 @@ impl VramImage {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct VramImageHandle { pub struct ImageHandle {
size: [f32; 2], size: [f32; 2],
data: Arc<Mutex<Option<Arc<ColorImage>>>>, data: Arc<Mutex<Option<Arc<ColorImage>>>>,
} }
impl VramImageHandle { impl ImageHandle {
fn pull(&mut self) -> Option<Arc<ColorImage>> { fn pull(&mut self) -> Option<Arc<ColorImage>> {
self.data.lock().unwrap().take() self.data.lock().unwrap().take()
} }
} }
pub struct VramParams<T> { pub struct ImageParams<T> {
value: T, value: T,
sink: Arc<Mutex<T>>, sink: Arc<Mutex<T>>,
} }
impl<T> Deref for VramParams<T> { impl<T> Deref for ImageParams<T> {
type Target = T; type Target = T;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
@ -167,7 +167,7 @@ impl<T> Deref for VramParams<T> {
} }
} }
impl<T: Clone + Eq> VramParams<T> { impl<T: Clone + Eq> ImageParams<T> {
pub fn write(&mut self, value: T) { pub fn write(&mut self, value: T) {
if self.value != value { if self.value != value {
self.value = value.clone(); self.value = value.clone();
@ -176,21 +176,21 @@ impl<T: Clone + Eq> VramParams<T> {
} }
} }
pub trait VramRenderer<const N: usize>: Send { pub trait ImageRenderer<const N: usize>: Send {
type Params: Clone + Send; type Params: Clone + Send;
fn sizes(&self) -> [[usize; 2]; N]; fn sizes(&self) -> [[usize; 2]; N];
fn render(&mut self, params: &Self::Params, images: &mut [VramImage; N]); fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; N]);
} }
#[derive(Clone)] #[derive(Clone)]
struct VramRenderImageState { struct ImageState {
size: [usize; 2], size: [usize; 2],
buffers: [Arc<ColorImage>; 2], buffers: [Arc<ColorImage>; 2],
last_buffer: usize, last_buffer: usize,
sink: Arc<Mutex<Option<Arc<ColorImage>>>>, sink: Arc<Mutex<Option<Arc<ColorImage>>>>,
} }
impl VramRenderImageState { impl ImageState {
fn new(size: [usize; 2]) -> Self { fn new(size: [usize; 2]) -> Self {
let buffers = [ let buffers = [
Arc::new(ColorImage::new(size, Color32::BLACK)), Arc::new(ColorImage::new(size, Color32::BLACK)),
@ -204,7 +204,7 @@ impl VramRenderImageState {
sink: Arc::new(Mutex::new(Some(sink))), sink: Arc::new(Mutex::new(Some(sink))),
} }
} }
fn try_send_update(&mut self, image: &VramImage) { fn try_send_update(&mut self, image: &ImageBuffer) {
let last = &self.buffers[self.last_buffer]; let last = &self.buffers[self.last_buffer];
if !image.changed(last) { if !image.changed(last) {
return; return;
@ -218,18 +218,18 @@ impl VramRenderImageState {
} }
} }
struct VramRendererWrapper<const N: usize, R: VramRenderer<N>> { struct ImageRendererWrapper<const N: usize, R: ImageRenderer<N>> {
renderer: R, renderer: R,
params: Weak<Mutex<R::Params>>, params: Weak<Mutex<R::Params>>,
images: [VramImage; N], images: [ImageBuffer; N],
states: [VramRenderImageState; N], states: [ImageState; N],
} }
trait VramRendererImpl: Send { trait ImageRendererImpl: Send {
fn try_update(&mut self) -> Result<(), ()>; fn try_update(&mut self) -> Result<(), ()>;
} }
impl<const N: usize, R: VramRenderer<N> + Send> VramRendererImpl for VramRendererWrapper<N, R> { impl<const N: usize, R: ImageRenderer<N> + Send> ImageRendererImpl for ImageRendererWrapper<N, R> {
fn try_update(&mut self) -> Result<(), ()> { fn try_update(&mut self) -> Result<(), ()> {
let params = match self.params.upgrade() { let params = match self.params.upgrade() {
Some(params) => params.lock().unwrap().clone(), Some(params) => params.lock().unwrap().clone(),
@ -247,12 +247,12 @@ impl<const N: usize, R: VramRenderer<N> + Send> VramRendererImpl for VramRendere
} }
} }
pub struct VramTextureLoader { pub struct ImageTextureLoader {
cache: Mutex<HashMap<String, (VramImageHandle, Option<TextureHandle>)>>, cache: Mutex<HashMap<String, (ImageHandle, Option<TextureHandle>)>>,
} }
impl VramTextureLoader { impl ImageTextureLoader {
pub fn new(renderers: impl IntoIterator<Item = (String, VramImageHandle)>) -> Self { pub fn new(renderers: impl IntoIterator<Item = (String, ImageHandle)>) -> Self {
let mut cache = HashMap::new(); let mut cache = HashMap::new();
for (key, image) in renderers { for (key, image) in renderers {
cache.insert(key, (image, None)); cache.insert(key, (image, None));
@ -263,9 +263,9 @@ impl VramTextureLoader {
} }
} }
impl TextureLoader for VramTextureLoader { impl TextureLoader for ImageTextureLoader {
fn id(&self) -> &str { fn id(&self) -> &str {
concat!(module_path!(), "VramTextureLoader") concat!(module_path!(), "ImageTextureLoader")
} }
fn load( fn load(

2
src/main.rs
View File

@ -18,10 +18,10 @@ mod controller;
mod emulator; mod emulator;
mod gdbserver; mod gdbserver;
mod graphics; mod graphics;
mod images;
mod input; mod input;
mod memory; mod memory;
mod persistence; mod persistence;
mod vram;
mod window; mod window;
#[derive(Parser)] #[derive(Parser)]

2
src/memory.rs
View File

@ -263,7 +263,7 @@ impl MemoryRegion {
/* /*
* We have four buffers, and (at time of writing) only three threads interacting with memory: * We have four buffers, and (at time of writing) only three threads interacting with memory:
* - The UI thread, reading small regions of memory * - The UI thread, reading small regions of memory
* - The "vram renderer" thread, reading large regions of memory * - The "image renderer" thread, reading large regions of memory
* - The emulation thread, writing memory every so often * - The emulation thread, writing memory every so often
* So it should be impossible for all four buffers to have a read lock at the same time, * So it should be impossible for all four buffers to have a read lock at the same time,
* and (because readers always read the newest buffer) at least one of the oldest three * and (because readers always read the newest buffer) at least one of the oldest three

4
src/window.rs
View File

@ -3,7 +3,7 @@ use egui::{Context, ViewportBuilder, ViewportId};
pub use game::GameWindow; pub use game::GameWindow;
pub use gdb::GdbServerWindow; pub use gdb::GdbServerWindow;
pub use input::InputWindow; pub use input::InputWindow;
pub use vram::{ pub use vip::{
BgMapWindow, CharacterDataWindow, FrameBufferWindow, ObjectWindow, RegisterWindow, WorldWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, ObjectWindow, RegisterWindow, WorldWindow,
}; };
use winit::event::KeyEvent; use winit::event::KeyEvent;
@ -16,7 +16,7 @@ mod game_screen;
mod gdb; mod gdb;
mod input; mod input;
mod utils; mod utils;
mod vram; mod vip;
pub trait AppWindow { pub trait AppWindow {
fn viewport_id(&self) -> ViewportId; fn viewport_id(&self) -> ViewportId;

0
src/window/vram.rs → src/window/vip.rs
View File

24
src/window/vram/bgmap.rs → src/window/vip/bgmap.rs
View File

@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{ use crate::{
emulator::SimId, emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView}, memory::{MemoryClient, MemoryView},
vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader},
window::{ window::{
utils::{NumberEdit, UiExt}, utils::{NumberEdit, UiExt},
AppWindow, AppWindow,
@ -20,22 +20,22 @@ use super::utils::{self, CellData, CharacterGrid};
pub struct BgMapWindow { pub struct BgMapWindow {
sim_id: SimId, sim_id: SimId,
loader: Arc<VramTextureLoader>, loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>, memory: Arc<MemoryClient>,
bgmaps: MemoryView, bgmaps: MemoryView,
cell_index: usize, cell_index: usize,
generic_palette: bool, generic_palette: bool,
params: VramParams<BgMapParams>, params: ImageParams<BgMapParams>,
scale: f32, scale: f32,
show_grid: bool, show_grid: bool,
} }
impl BgMapWindow { impl BgMapWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, vram: &mut VramProcessor) -> Self { pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, images: &mut ImageProcessor) -> Self {
let renderer = BgMapRenderer::new(sim_id, memory); let renderer = BgMapRenderer::new(sim_id, memory);
let ([cell, bgmap], params) = vram.add(renderer, BgMapParams::default()); let ([cell, bgmap], params) = images.add(renderer, BgMapParams::default());
let loader = let loader =
VramTextureLoader::new([("vram://cell".into(), cell), ("vram://bgmap".into(), bgmap)]); ImageTextureLoader::new([("vip://cell".into(), cell), ("vip://bgmap".into(), bgmap)]);
Self { Self {
sim_id, sim_id,
loader: Arc::new(loader), loader: Arc::new(loader),
@ -90,7 +90,7 @@ impl BgMapWindow {
}); });
}); });
}); });
let image = Image::new("vram://cell") let image = Image::new("vip://cell")
.maintain_aspect_ratio(true) .maintain_aspect_ratio(true)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -162,7 +162,7 @@ impl BgMapWindow {
} }
fn show_bgmap(&mut self, ui: &mut Ui) { fn show_bgmap(&mut self, ui: &mut Ui) {
let grid = CharacterGrid::new("vram://bgmap") let grid = CharacterGrid::new("vip://bgmap")
.with_scale(self.scale) .with_scale(self.scale)
.with_grid(self.show_grid) .with_grid(self.show_grid)
.with_selected(self.cell_index % 4096); .with_selected(self.cell_index % 4096);
@ -233,7 +233,7 @@ impl BgMapRenderer {
} }
} }
fn render_bgmap(&self, image: &mut VramImage, bgmap_index: usize, generic_palette: bool) { fn render_bgmap(&self, image: &mut ImageBuffer, bgmap_index: usize, generic_palette: bool) {
let chardata = self.chardata.borrow(); let chardata = self.chardata.borrow();
let bgmaps = self.bgmaps.borrow(); let bgmaps = self.bgmaps.borrow();
let brightness = self.brightness.borrow(); let brightness = self.brightness.borrow();
@ -266,7 +266,7 @@ impl BgMapRenderer {
} }
} }
fn render_bgmap_cell(&self, image: &mut VramImage, index: usize, generic_palette: bool) { fn render_bgmap_cell(&self, image: &mut ImageBuffer, index: usize, generic_palette: bool) {
let chardata = self.chardata.borrow(); let chardata = self.chardata.borrow();
let bgmaps = self.bgmaps.borrow(); let bgmaps = self.bgmaps.borrow();
let brightness = self.brightness.borrow(); let brightness = self.brightness.borrow();
@ -297,14 +297,14 @@ impl BgMapRenderer {
} }
} }
impl VramRenderer<2> for BgMapRenderer { impl ImageRenderer<2> for BgMapRenderer {
type Params = BgMapParams; type Params = BgMapParams;
fn sizes(&self) -> [[usize; 2]; 2] { fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [8 * 64, 8 * 64]] [[8, 8], [8 * 64, 8 * 64]]
} }
fn render(&mut self, params: &Self::Params, images: &mut [VramImage; 2]) { 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_cell(&mut images[0], params.cell_index, params.generic_palette);
self.render_bgmap( self.render_bgmap(
&mut images[1], &mut images[1],

48
src/window/vram/chardata.rs → src/window/vip/chardata.rs
View File

@ -9,8 +9,8 @@ use serde::{Deserialize, Serialize};
use crate::{ use crate::{
emulator::SimId, emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView}, memory::{MemoryClient, MemoryView},
vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader},
window::{ window::{
utils::{NumberEdit, UiExt as _}, utils::{NumberEdit, UiExt as _},
AppWindow, AppWindow,
@ -20,7 +20,7 @@ use crate::{
use super::utils::{self, CharacterGrid}; use super::utils::{self, CharacterGrid};
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VramPalette { pub enum Palette {
#[default] #[default]
Generic, Generic,
Bg0, Bg0,
@ -33,8 +33,8 @@ pub enum VramPalette {
Obj3, Obj3,
} }
impl VramPalette { impl Palette {
pub const fn values() -> [VramPalette; 9] { pub const fn values() -> [Palette; 9] {
[ [
Self::Generic, Self::Generic,
Self::Bg0, Self::Bg0,
@ -63,7 +63,7 @@ impl VramPalette {
} }
} }
impl Display for VramPalette { impl Display for Palette {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { match self {
Self::Generic => f.write_str("Generic"), Self::Generic => f.write_str("Generic"),
@ -81,23 +81,23 @@ impl Display for VramPalette {
pub struct CharacterDataWindow { pub struct CharacterDataWindow {
sim_id: SimId, sim_id: SimId,
loader: Arc<VramTextureLoader>, loader: Arc<ImageTextureLoader>,
brightness: MemoryView, brightness: MemoryView,
palettes: MemoryView, palettes: MemoryView,
palette: VramPalette, palette: Palette,
index: usize, index: usize,
params: VramParams<CharDataParams>, params: ImageParams<CharDataParams>,
scale: f32, scale: f32,
show_grid: bool, show_grid: bool,
} }
impl CharacterDataWindow { impl CharacterDataWindow {
pub fn new(sim_id: SimId, memory: &MemoryClient, vram: &mut VramProcessor) -> Self { pub fn new(sim_id: SimId, memory: &MemoryClient, images: &mut ImageProcessor) -> Self {
let renderer = CharDataRenderer::new(sim_id, memory); let renderer = CharDataRenderer::new(sim_id, memory);
let ([char, chardata], params) = vram.add(renderer, CharDataParams::default()); let ([char, chardata], params) = images.add(renderer, CharDataParams::default());
let loader = VramTextureLoader::new([ let loader = ImageTextureLoader::new([
("vram://char".into(), char), ("vip://char".into(), char),
("vram://chardata".into(), chardata), ("vip://chardata".into(), chardata),
]); ]);
Self { Self {
sim_id, sim_id,
@ -160,7 +160,7 @@ impl CharacterDataWindow {
}); });
}); });
}); });
let image = Image::new("vram://char") let image = Image::new("vip://char")
.maintain_aspect_ratio(true) .maintain_aspect_ratio(true)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -171,7 +171,7 @@ impl CharacterDataWindow {
.selected_text(self.palette.to_string()) .selected_text(self.palette.to_string())
.width(ui.available_width()) .width(ui.available_width())
.show_ui(ui, |ui| { .show_ui(ui, |ui| {
for palette in VramPalette::values() { for palette in Palette::values() {
ui.selectable_value( ui.selectable_value(
&mut self.palette, &mut self.palette,
palette, palette,
@ -226,7 +226,7 @@ impl CharacterDataWindow {
} }
fn show_chardata(&mut self, ui: &mut Ui) { fn show_chardata(&mut self, ui: &mut Ui) {
let grid = CharacterGrid::new("vram://chardata") let grid = CharacterGrid::new("vip://chardata")
.with_scale(self.scale) .with_scale(self.scale)
.with_grid(self.show_grid) .with_grid(self.show_grid)
.with_selected(self.index); .with_selected(self.index);
@ -276,13 +276,13 @@ impl AppWindow for CharacterDataWindow {
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)] #[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
enum CharDataResource { enum CharDataResource {
Character { palette: VramPalette, index: usize }, Character { palette: Palette, index: usize },
CharacterData { palette: VramPalette }, CharacterData { palette: Palette },
} }
#[derive(Clone, Default, PartialEq, Eq)] #[derive(Clone, Default, PartialEq, Eq)]
struct CharDataParams { struct CharDataParams {
palette: VramPalette, palette: Palette,
index: usize, index: usize,
} }
@ -292,14 +292,14 @@ struct CharDataRenderer {
palettes: MemoryView, palettes: MemoryView,
} }
impl VramRenderer<2> for CharDataRenderer { impl ImageRenderer<2> for CharDataRenderer {
type Params = CharDataParams; type Params = CharDataParams;
fn sizes(&self) -> [[usize; 2]; 2] { fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [16 * 8, 128 * 8]] [[8, 8], [16 * 8, 128 * 8]]
} }
fn render(&mut self, params: &Self::Params, image: &mut [VramImage; 2]) { fn render(&mut self, params: &Self::Params, image: &mut [ImageBuffer; 2]) {
self.render_character(&mut image[0], params.palette, params.index); self.render_character(&mut image[0], params.palette, params.index);
self.render_character_data(&mut image[1], params.palette); self.render_character_data(&mut image[1], params.palette);
} }
@ -314,7 +314,7 @@ impl CharDataRenderer {
} }
} }
fn render_character(&self, image: &mut VramImage, palette: VramPalette, index: usize) { fn render_character(&self, image: &mut ImageBuffer, palette: Palette, index: usize) {
if index >= 2048 { if index >= 2048 {
return; return;
} }
@ -329,7 +329,7 @@ impl CharDataRenderer {
} }
} }
fn render_character_data(&self, image: &mut VramImage, palette: VramPalette) { fn render_character_data(&self, image: &mut ImageBuffer, palette: Palette) {
let palette = self.load_palette(palette); let palette = self.load_palette(palette);
let chardata = self.chardata.borrow(); let chardata = self.chardata.borrow();
for (row, pixels) in chardata.range::<u16>(0, 8 * 2048).enumerate() { for (row, pixels) in chardata.range::<u16>(0, 8 * 2048).enumerate() {
@ -344,7 +344,7 @@ impl CharDataRenderer {
} }
} }
fn load_palette(&self, palette: VramPalette) -> [Color32; 4] { fn load_palette(&self, palette: Palette) -> [Color32; 4] {
let Some(offset) = palette.offset() else { let Some(offset) = palette.offset() else {
return utils::GENERIC_PALETTE.map(|p| utils::shade(p, Color32::RED)); return utils::GENERIC_PALETTE.map(|p| utils::shade(p, Color32::RED));
}; };

18
src/window/vram/framebuffer.rs → src/window/vip/framebuffer.rs
View File

@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{ use crate::{
emulator::SimId, emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView}, memory::{MemoryClient, MemoryView},
vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader},
window::{ window::{
utils::{NumberEdit, UiExt as _}, utils::{NumberEdit, UiExt as _},
AppWindow, AppWindow,
@ -20,17 +20,17 @@ use super::utils;
pub struct FrameBufferWindow { pub struct FrameBufferWindow {
sim_id: SimId, sim_id: SimId,
loader: Arc<VramTextureLoader>, loader: Arc<ImageTextureLoader>,
index: usize, index: usize,
left: bool, left: bool,
right: bool, right: bool,
generic_palette: bool, generic_palette: bool,
params: VramParams<FrameBufferParams>, params: ImageParams<FrameBufferParams>,
scale: f32, scale: f32,
} }
impl FrameBufferWindow { impl FrameBufferWindow {
pub fn new(sim_id: SimId, memory: &MemoryClient, vram: &mut VramProcessor) -> Self { pub fn new(sim_id: SimId, memory: &MemoryClient, images: &mut ImageProcessor) -> Self {
let initial_params = FrameBufferParams { let initial_params = FrameBufferParams {
index: 0, index: 0,
left: true, left: true,
@ -40,8 +40,8 @@ impl FrameBufferWindow {
right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), right_color: Color32::from_rgb(0x00, 0xc6, 0xf0),
}; };
let renderer = FrameBufferRenderer::new(sim_id, memory); let renderer = FrameBufferRenderer::new(sim_id, memory);
let ([buffer], params) = vram.add(renderer, initial_params); let ([buffer], params) = images.add(renderer, initial_params);
let loader = VramTextureLoader::new([("vram://buffer".into(), buffer)]); let loader = ImageTextureLoader::new([("vip://buffer".into(), buffer)]);
Self { Self {
sim_id, sim_id,
loader: Arc::new(loader), loader: Arc::new(loader),
@ -131,7 +131,7 @@ impl FrameBufferWindow {
} }
fn show_buffers(&mut self, ui: &mut Ui) { fn show_buffers(&mut self, ui: &mut Ui) {
let image = Image::new("vram://buffer") let image = Image::new("vip://buffer")
.fit_to_original_size(self.scale) .fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -205,14 +205,14 @@ impl FrameBufferRenderer {
} }
} }
impl VramRenderer<1> for FrameBufferRenderer { impl ImageRenderer<1> for FrameBufferRenderer {
type Params = FrameBufferParams; type Params = FrameBufferParams;
fn sizes(&self) -> [[usize; 2]; 1] { fn sizes(&self) -> [[usize; 2]; 1] {
[[384, 224]] [[384, 224]]
} }
fn render(&mut self, params: &Self::Params, images: &mut [VramImage; 1]) { fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 1]) {
let image = &mut images[0]; let image = &mut images[0];
let left_buffer = self.buffers[params.index * 2].borrow(); let left_buffer = self.buffers[params.index * 2].borrow();

28
src/window/vram/object.rs → src/window/vip/object.rs
View File

@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder};
use crate::{ use crate::{
emulator::SimId, emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryView}, memory::{MemoryClient, MemoryView},
vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader},
window::{ window::{
utils::{NumberEdit, UiExt as _}, utils::{NumberEdit, UiExt as _},
AppWindow, AppWindow,
@ -20,17 +20,17 @@ use super::utils::{self, Object};
pub struct ObjectWindow { pub struct ObjectWindow {
sim_id: SimId, sim_id: SimId,
loader: Arc<VramTextureLoader>, loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>, memory: Arc<MemoryClient>,
objects: MemoryView, objects: MemoryView,
index: usize, index: usize,
generic_palette: bool, generic_palette: bool,
params: VramParams<ObjectParams>, params: ImageParams<ObjectParams>,
scale: f32, scale: f32,
} }
impl ObjectWindow { impl ObjectWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, vram: &mut VramProcessor) -> Self { pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, images: &mut ImageProcessor) -> Self {
let initial_params = ObjectParams { let initial_params = ObjectParams {
index: 0, index: 0,
generic_palette: false, generic_palette: false,
@ -38,9 +38,9 @@ impl ObjectWindow {
right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), right_color: Color32::from_rgb(0x00, 0xc6, 0xf0),
}; };
let renderer = ObjectRenderer::new(sim_id, memory); let renderer = ObjectRenderer::new(sim_id, memory);
let ([zoom, full], params) = vram.add(renderer, initial_params); let ([zoom, full], params) = images.add(renderer, initial_params);
let loader = let loader =
VramTextureLoader::new([("vram://zoom".into(), zoom), ("vram://full".into(), full)]); ImageTextureLoader::new([("vip://zoom".into(), zoom), ("vip://full".into(), full)]);
Self { Self {
sim_id, sim_id,
loader: Arc::new(loader), loader: Arc::new(loader),
@ -82,7 +82,7 @@ impl ObjectWindow {
}); });
}); });
}); });
let image = Image::new("vram://zoom") let image = Image::new("vip://zoom")
.maintain_aspect_ratio(true) .maintain_aspect_ratio(true)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -186,7 +186,7 @@ impl ObjectWindow {
} }
fn show_object(&mut self, ui: &mut Ui) { fn show_object(&mut self, ui: &mut Ui) {
let image = Image::new("vram://full") let image = Image::new("vip://full")
.fit_to_original_size(self.scale) .fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -261,7 +261,13 @@ impl ObjectRenderer {
} }
} }
fn render_object(&self, image: &mut VramImage, params: &ObjectParams, use_pos: bool, eye: Eye) { fn render_object(
&self,
image: &mut ImageBuffer,
params: &ObjectParams,
use_pos: bool,
eye: Eye,
) {
let chardata = self.chardata.borrow(); let chardata = self.chardata.borrow();
let objects = self.objects.borrow(); let objects = self.objects.borrow();
let brightness = self.brightness.borrow(); let brightness = self.brightness.borrow();
@ -318,14 +324,14 @@ impl ObjectRenderer {
} }
} }
impl VramRenderer<2> for ObjectRenderer { impl ImageRenderer<2> for ObjectRenderer {
type Params = ObjectParams; type Params = ObjectParams;
fn sizes(&self) -> [[usize; 2]; 2] { fn sizes(&self) -> [[usize; 2]; 2] {
[[8, 8], [384, 224]] [[8, 8], [384, 224]]
} }
fn render(&mut self, params: &Self::Params, images: &mut [VramImage; 2]) { fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 2]) {
images[0].clear(); images[0].clear();
self.render_object(&mut images[0], params, false, Eye::Left); self.render_object(&mut images[0], params, false, Eye::Left);
self.render_object(&mut images[0], params, false, Eye::Right); self.render_object(&mut images[0], params, false, Eye::Right);

0
src/window/vram/registers.rs → src/window/vip/registers.rs
View File

0
src/window/vram/utils.rs → src/window/vip/utils.rs
View File

22
src/window/vram/world.rs → src/window/vip/world.rs
View File

@ -14,8 +14,8 @@ use num_traits::{FromPrimitive, ToPrimitive};
use crate::{ use crate::{
emulator::SimId, emulator::SimId,
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
memory::{MemoryClient, MemoryRef, MemoryView}, memory::{MemoryClient, MemoryRef, MemoryView},
vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader},
window::{ window::{
utils::{NumberEdit, UiExt as _}, utils::{NumberEdit, UiExt as _},
AppWindow, AppWindow,
@ -26,19 +26,19 @@ use super::utils::{self, shade, CellData, Object};
pub struct WorldWindow { pub struct WorldWindow {
sim_id: SimId, sim_id: SimId,
loader: Arc<VramTextureLoader>, loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>, memory: Arc<MemoryClient>,
worlds: MemoryView, worlds: MemoryView,
bgmaps: MemoryView, bgmaps: MemoryView,
index: usize, index: usize,
param_index: usize, param_index: usize,
generic_palette: bool, generic_palette: bool,
params: VramParams<WorldParams>, params: ImageParams<WorldParams>,
scale: f32, scale: f32,
} }
impl WorldWindow { impl WorldWindow {
pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, vram: &mut VramProcessor) -> Self { pub fn new(sim_id: SimId, memory: &Arc<MemoryClient>, images: &mut ImageProcessor) -> Self {
let initial_params = WorldParams { let initial_params = WorldParams {
index: 31, index: 31,
generic_palette: false, generic_palette: false,
@ -46,8 +46,8 @@ impl WorldWindow {
right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), right_color: Color32::from_rgb(0x00, 0xc6, 0xf0),
}; };
let renderer = WorldRenderer::new(sim_id, memory); let renderer = WorldRenderer::new(sim_id, memory);
let ([world], params) = vram.add(renderer, initial_params); let ([world], params) = images.add(renderer, initial_params);
let loader = VramTextureLoader::new([("vram://world".into(), world)]); let loader = ImageTextureLoader::new([("vip://world".into(), world)]);
Self { Self {
sim_id, sim_id,
loader: Arc::new(loader), loader: Arc::new(loader),
@ -423,7 +423,7 @@ impl WorldWindow {
} }
fn show_world(&mut self, ui: &mut Ui) { fn show_world(&mut self, ui: &mut Ui) {
let image = Image::new("vram://world") let image = Image::new("vip://world")
.fit_to_original_size(self.scale) .fit_to_original_size(self.scale)
.texture_options(TextureOptions::NEAREST); .texture_options(TextureOptions::NEAREST);
ui.add(image); ui.add(image);
@ -507,7 +507,7 @@ impl WorldRenderer {
} }
} }
fn render_object_world(&mut self, group: usize, params: &WorldParams, image: &mut VramImage) { fn render_object_world(&mut self, group: usize, params: &WorldParams, image: &mut ImageBuffer) {
for cell in self.buffer.iter_mut() { for cell in self.buffer.iter_mut() {
*cell = [0, 0]; *cell = [0, 0];
} }
@ -604,7 +604,7 @@ impl WorldRenderer {
} }
} }
fn render_world(&mut self, world: World, params: &WorldParams, image: &mut VramImage) { fn render_world(&mut self, world: World, params: &WorldParams, image: &mut ImageBuffer) {
image.clear(); image.clear();
let width = if world.header.mode == WorldMode::Affine { let width = if world.header.mode == WorldMode::Affine {
@ -687,14 +687,14 @@ impl WorldRenderer {
} }
} }
impl VramRenderer<1> for WorldRenderer { impl ImageRenderer<1> for WorldRenderer {
type Params = WorldParams; type Params = WorldParams;
fn sizes(&self) -> [[usize; 2]; 1] { fn sizes(&self) -> [[usize; 2]; 1] {
[[384, 224]] [[384, 224]]
} }
fn render(&mut self, params: &Self::Params, images: &mut [VramImage; 1]) { fn render(&mut self, params: &Self::Params, images: &mut [ImageBuffer; 1]) {
let image = &mut images[0]; let image = &mut images[0];
let worlds = self.worlds.borrow(); let worlds = self.worlds.borrow();