From 6ab9d2ee53d980304e0a42b069f834b955da0494 Mon Sep 17 00:00:00 2001 From: Simon Gellis Date: Sun, 23 Feb 2025 22:44:11 -0500 Subject: [PATCH] Rename vram to vip internally --- src/app.rs | 20 +++---- src/{vram.rs => images.rs} | 76 ++++++++++++------------- src/main.rs | 2 +- src/memory.rs | 2 +- src/window.rs | 4 +- src/window/{vram.rs => vip.rs} | 0 src/window/{vram => vip}/bgmap.rs | 24 ++++---- src/window/{vram => vip}/chardata.rs | 48 ++++++++-------- src/window/{vram => vip}/framebuffer.rs | 18 +++--- src/window/{vram => vip}/object.rs | 28 +++++---- src/window/{vram => vip}/registers.rs | 0 src/window/{vram => vip}/utils.rs | 0 src/window/{vram => vip}/world.rs | 22 +++---- 13 files changed, 125 insertions(+), 119 deletions(-) rename src/{vram.rs => images.rs} (81%) rename src/window/{vram.rs => vip.rs} (100%) rename src/window/{vram => vip}/bgmap.rs (92%) rename src/window/{vram => vip}/chardata.rs (89%) rename src/window/{vram => vip}/framebuffer.rs (93%) rename src/window/{vram => vip}/object.rs (93%) rename src/window/{vram => vip}/registers.rs (100%) rename src/window/{vram => vip}/utils.rs (100%) rename src/window/{vram => vip}/world.rs (98%) diff --git a/src/app.rs b/src/app.rs index 2ceaf4f..8030986 100644 --- a/src/app.rs +++ b/src/app.rs @@ -17,10 +17,10 @@ use winit::{ use crate::{ controller::ControllerManager, emulator::{EmulatorClient, EmulatorCommand, SimId}, + images::ImageProcessor, input::MappingProvider, memory::MemoryClient, persistence::Persistence, - vram::VramProcessor, window::{ AboutWindow, AppWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, GameWindow, GdbServerWindow, InputWindow, ObjectWindow, RegisterWindow, WorldWindow, @@ -46,7 +46,7 @@ pub struct Application { mappings: MappingProvider, controllers: ControllerManager, memory: Arc, - vram: VramProcessor, + images: ImageProcessor, persistence: Persistence, viewports: HashMap, focused: Option, @@ -65,7 +65,7 @@ impl Application { let mappings = MappingProvider::new(persistence.clone()); let controllers = ControllerManager::new(client.clone(), &mappings); let memory = Arc::new(MemoryClient::new(client.clone())); - let vram = VramProcessor::new(); + let images = ImageProcessor::new(); { let mappings = mappings.clone(); let proxy = proxy.clone(); @@ -78,7 +78,7 @@ impl Application { proxy, mappings, memory, - vram, + images, controllers, persistence, viewports: HashMap::new(), @@ -214,23 +214,23 @@ impl ApplicationHandler for Application { self.open(event_loop, Box::new(about)); } UserEvent::OpenCharacterData(sim_id) => { - let vram = CharacterDataWindow::new(sim_id, &self.memory, &mut self.vram); - self.open(event_loop, Box::new(vram)); + let chardata = CharacterDataWindow::new(sim_id, &self.memory, &mut self.images); + self.open(event_loop, Box::new(chardata)); } 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)); } 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)); } 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)); } 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)); } UserEvent::OpenRegisters(sim_id) => { diff --git a/src/vram.rs b/src/images.rs similarity index 81% rename from src/vram.rs rename to src/images.rs index 88e5e89..1730aa8 100644 --- a/src/vram.rs +++ b/src/images.rs @@ -13,11 +13,11 @@ use egui::{ }; use tokio::{sync::mpsc, time::timeout}; -pub struct VramProcessor { - sender: mpsc::UnboundedSender>, +pub struct ImageProcessor { + sender: mpsc::UnboundedSender>, } -impl VramProcessor { +impl ImageProcessor { pub fn new() -> Self { let (sender, receiver) = mpsc::unbounded_channel(); thread::spawn(move || { @@ -26,7 +26,7 @@ impl VramProcessor { .build() .unwrap() .block_on(async move { - let mut worker = VramProcessorWorker { + let mut worker = ImageProcessorWorker { receiver, renderers: vec![], }; @@ -36,27 +36,27 @@ impl VramProcessor { Self { sender } } - pub fn add + 'static>( + pub fn add + 'static>( &self, renderer: R, params: R::Params, - ) -> ([VramImageHandle; N], VramParams) { - let states = renderer.sizes().map(VramRenderImageState::new); - let handles = states.clone().map(|state| VramImageHandle { + ) -> ([ImageHandle; N], ImageParams) { + let states = renderer.sizes().map(ImageState::new); + let handles = states.clone().map(|state| ImageHandle { size: state.size.map(|i| i as f32), data: state.sink, }); let images = renderer .sizes() - .map(|[width, height]| VramImage::new(width, height)); + .map(|[width, height]| ImageBuffer::new(width, height)); let sink = Arc::new(Mutex::new(params.clone())); - let _ = self.sender.send(Box::new(VramRendererWrapper { + let _ = self.sender.send(Box::new(ImageRendererWrapper { renderer, params: Arc::downgrade(&sink), images, states, })); - let params = VramParams { + let params = ImageParams { value: params, sink, }; @@ -64,12 +64,12 @@ impl VramProcessor { } } -struct VramProcessorWorker { - receiver: mpsc::UnboundedReceiver>, - renderers: Vec>, +struct ImageProcessorWorker { + receiver: mpsc::UnboundedReceiver>, + renderers: Vec>, } -impl VramProcessorWorker { +impl ImageProcessorWorker { async fn run(&mut self) { loop { if self.renderers.is_empty() { @@ -100,12 +100,12 @@ impl VramProcessorWorker { } } -pub struct VramImage { +pub struct ImageBuffer { pub size: [usize; 2], pub pixels: Vec, } -impl VramImage { +impl ImageBuffer { pub fn new(width: usize, height: usize) -> Self { Self { size: [width, height], @@ -143,23 +143,23 @@ impl VramImage { } #[derive(Clone)] -pub struct VramImageHandle { +pub struct ImageHandle { size: [f32; 2], data: Arc>>>, } -impl VramImageHandle { +impl ImageHandle { fn pull(&mut self) -> Option> { self.data.lock().unwrap().take() } } -pub struct VramParams { +pub struct ImageParams { value: T, sink: Arc>, } -impl Deref for VramParams { +impl Deref for ImageParams { type Target = T; fn deref(&self) -> &Self::Target { @@ -167,7 +167,7 @@ impl Deref for VramParams { } } -impl VramParams { +impl ImageParams { pub fn write(&mut self, value: T) { if self.value != value { self.value = value.clone(); @@ -176,21 +176,21 @@ impl VramParams { } } -pub trait VramRenderer: Send { +pub trait ImageRenderer: Send { type Params: Clone + Send; 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)] -struct VramRenderImageState { +struct ImageState { size: [usize; 2], buffers: [Arc; 2], last_buffer: usize, sink: Arc>>>, } -impl VramRenderImageState { +impl ImageState { fn new(size: [usize; 2]) -> Self { let buffers = [ Arc::new(ColorImage::new(size, Color32::BLACK)), @@ -204,7 +204,7 @@ impl VramRenderImageState { 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]; if !image.changed(last) { return; @@ -218,18 +218,18 @@ impl VramRenderImageState { } } -struct VramRendererWrapper> { +struct ImageRendererWrapper> { renderer: R, params: Weak>, - images: [VramImage; N], - states: [VramRenderImageState; N], + images: [ImageBuffer; N], + states: [ImageState; N], } -trait VramRendererImpl: Send { +trait ImageRendererImpl: Send { fn try_update(&mut self) -> Result<(), ()>; } -impl + Send> VramRendererImpl for VramRendererWrapper { +impl + Send> ImageRendererImpl for ImageRendererWrapper { fn try_update(&mut self) -> Result<(), ()> { let params = match self.params.upgrade() { Some(params) => params.lock().unwrap().clone(), @@ -247,12 +247,12 @@ impl + Send> VramRendererImpl for VramRendere } } -pub struct VramTextureLoader { - cache: Mutex)>>, +pub struct ImageTextureLoader { + cache: Mutex)>>, } -impl VramTextureLoader { - pub fn new(renderers: impl IntoIterator) -> Self { +impl ImageTextureLoader { + pub fn new(renderers: impl IntoIterator) -> Self { let mut cache = HashMap::new(); for (key, image) in renderers { cache.insert(key, (image, None)); @@ -263,9 +263,9 @@ impl VramTextureLoader { } } -impl TextureLoader for VramTextureLoader { +impl TextureLoader for ImageTextureLoader { fn id(&self) -> &str { - concat!(module_path!(), "VramTextureLoader") + concat!(module_path!(), "ImageTextureLoader") } fn load( diff --git a/src/main.rs b/src/main.rs index 5b43893..eb160b8 100644 --- a/src/main.rs +++ b/src/main.rs @@ -18,10 +18,10 @@ mod controller; mod emulator; mod gdbserver; mod graphics; +mod images; mod input; mod memory; mod persistence; -mod vram; mod window; #[derive(Parser)] diff --git a/src/memory.rs b/src/memory.rs index 96fde14..92b10d5 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -263,7 +263,7 @@ impl MemoryRegion { /* * We have four buffers, and (at time of writing) only three threads interacting with 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 * 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 diff --git a/src/window.rs b/src/window.rs index 2216004..8ad5146 100644 --- a/src/window.rs +++ b/src/window.rs @@ -3,7 +3,7 @@ use egui::{Context, ViewportBuilder, ViewportId}; pub use game::GameWindow; pub use gdb::GdbServerWindow; pub use input::InputWindow; -pub use vram::{ +pub use vip::{ BgMapWindow, CharacterDataWindow, FrameBufferWindow, ObjectWindow, RegisterWindow, WorldWindow, }; use winit::event::KeyEvent; @@ -16,7 +16,7 @@ mod game_screen; mod gdb; mod input; mod utils; -mod vram; +mod vip; pub trait AppWindow { fn viewport_id(&self) -> ViewportId; diff --git a/src/window/vram.rs b/src/window/vip.rs similarity index 100% rename from src/window/vram.rs rename to src/window/vip.rs diff --git a/src/window/vram/bgmap.rs b/src/window/vip/bgmap.rs similarity index 92% rename from src/window/vram/bgmap.rs rename to src/window/vip/bgmap.rs index 25f7ca4..4a7a8c7 100644 --- a/src/window/vram/bgmap.rs +++ b/src/window/vip/bgmap.rs @@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder}; use crate::{ emulator::SimId, + images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader}, memory::{MemoryClient, MemoryView}, - vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader}, window::{ utils::{NumberEdit, UiExt}, AppWindow, @@ -20,22 +20,22 @@ use super::utils::{self, CellData, CharacterGrid}; pub struct BgMapWindow { sim_id: SimId, - loader: Arc, + loader: Arc, memory: Arc, bgmaps: MemoryView, cell_index: usize, generic_palette: bool, - params: VramParams, + params: ImageParams, scale: f32, show_grid: bool, } impl BgMapWindow { - pub fn new(sim_id: SimId, memory: &Arc, vram: &mut VramProcessor) -> Self { + pub fn new(sim_id: SimId, memory: &Arc, images: &mut ImageProcessor) -> Self { 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 = - VramTextureLoader::new([("vram://cell".into(), cell), ("vram://bgmap".into(), bgmap)]); + ImageTextureLoader::new([("vip://cell".into(), cell), ("vip://bgmap".into(), bgmap)]); Self { sim_id, 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) .texture_options(TextureOptions::NEAREST); ui.add(image); @@ -162,7 +162,7 @@ impl BgMapWindow { } 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_grid(self.show_grid) .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 bgmaps = self.bgmaps.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 bgmaps = self.bgmaps.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; fn sizes(&self) -> [[usize; 2]; 2] { [[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( &mut images[1], diff --git a/src/window/vram/chardata.rs b/src/window/vip/chardata.rs similarity index 89% rename from src/window/vram/chardata.rs rename to src/window/vip/chardata.rs index 3a6d841..3bddc7a 100644 --- a/src/window/vram/chardata.rs +++ b/src/window/vip/chardata.rs @@ -9,8 +9,8 @@ use serde::{Deserialize, Serialize}; use crate::{ emulator::SimId, + images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader}, memory::{MemoryClient, MemoryView}, - vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader}, window::{ utils::{NumberEdit, UiExt as _}, AppWindow, @@ -20,7 +20,7 @@ use crate::{ use super::utils::{self, CharacterGrid}; #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum VramPalette { +pub enum Palette { #[default] Generic, Bg0, @@ -33,8 +33,8 @@ pub enum VramPalette { Obj3, } -impl VramPalette { - pub const fn values() -> [VramPalette; 9] { +impl Palette { + pub const fn values() -> [Palette; 9] { [ Self::Generic, 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 { match self { Self::Generic => f.write_str("Generic"), @@ -81,23 +81,23 @@ impl Display for VramPalette { pub struct CharacterDataWindow { sim_id: SimId, - loader: Arc, + loader: Arc, brightness: MemoryView, palettes: MemoryView, - palette: VramPalette, + palette: Palette, index: usize, - params: VramParams, + params: ImageParams, scale: f32, show_grid: bool, } 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 ([char, chardata], params) = vram.add(renderer, CharDataParams::default()); - let loader = VramTextureLoader::new([ - ("vram://char".into(), char), - ("vram://chardata".into(), chardata), + let ([char, chardata], params) = images.add(renderer, CharDataParams::default()); + let loader = ImageTextureLoader::new([ + ("vip://char".into(), char), + ("vip://chardata".into(), chardata), ]); Self { sim_id, @@ -160,7 +160,7 @@ impl CharacterDataWindow { }); }); }); - let image = Image::new("vram://char") + let image = Image::new("vip://char") .maintain_aspect_ratio(true) .texture_options(TextureOptions::NEAREST); ui.add(image); @@ -171,7 +171,7 @@ impl CharacterDataWindow { .selected_text(self.palette.to_string()) .width(ui.available_width()) .show_ui(ui, |ui| { - for palette in VramPalette::values() { + for palette in Palette::values() { ui.selectable_value( &mut self.palette, palette, @@ -226,7 +226,7 @@ impl CharacterDataWindow { } 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_grid(self.show_grid) .with_selected(self.index); @@ -276,13 +276,13 @@ impl AppWindow for CharacterDataWindow { #[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)] enum CharDataResource { - Character { palette: VramPalette, index: usize }, - CharacterData { palette: VramPalette }, + Character { palette: Palette, index: usize }, + CharacterData { palette: Palette }, } #[derive(Clone, Default, PartialEq, Eq)] struct CharDataParams { - palette: VramPalette, + palette: Palette, index: usize, } @@ -292,14 +292,14 @@ struct CharDataRenderer { palettes: MemoryView, } -impl VramRenderer<2> for CharDataRenderer { +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 [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_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 { 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 chardata = self.chardata.borrow(); for (row, pixels) in chardata.range::(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 { return utils::GENERIC_PALETTE.map(|p| utils::shade(p, Color32::RED)); }; diff --git a/src/window/vram/framebuffer.rs b/src/window/vip/framebuffer.rs similarity index 93% rename from src/window/vram/framebuffer.rs rename to src/window/vip/framebuffer.rs index 3a2e722..ecd8e74 100644 --- a/src/window/vram/framebuffer.rs +++ b/src/window/vip/framebuffer.rs @@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder}; use crate::{ emulator::SimId, + images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader}, memory::{MemoryClient, MemoryView}, - vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader}, window::{ utils::{NumberEdit, UiExt as _}, AppWindow, @@ -20,17 +20,17 @@ use super::utils; pub struct FrameBufferWindow { sim_id: SimId, - loader: Arc, + loader: Arc, index: usize, left: bool, right: bool, generic_palette: bool, - params: VramParams, + params: ImageParams, scale: f32, } 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 { index: 0, left: true, @@ -40,8 +40,8 @@ impl FrameBufferWindow { right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), }; let renderer = FrameBufferRenderer::new(sim_id, memory); - let ([buffer], params) = vram.add(renderer, initial_params); - let loader = VramTextureLoader::new([("vram://buffer".into(), buffer)]); + let ([buffer], params) = images.add(renderer, initial_params); + let loader = ImageTextureLoader::new([("vip://buffer".into(), buffer)]); Self { sim_id, loader: Arc::new(loader), @@ -131,7 +131,7 @@ impl FrameBufferWindow { } 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) .texture_options(TextureOptions::NEAREST); ui.add(image); @@ -205,14 +205,14 @@ impl FrameBufferRenderer { } } -impl VramRenderer<1> for FrameBufferRenderer { +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 [VramImage; 1]) { + 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(); diff --git a/src/window/vram/object.rs b/src/window/vip/object.rs similarity index 93% rename from src/window/vram/object.rs rename to src/window/vip/object.rs index 656c2d1..0899113 100644 --- a/src/window/vram/object.rs +++ b/src/window/vip/object.rs @@ -8,8 +8,8 @@ use egui_extras::{Column, Size, StripBuilder, TableBuilder}; use crate::{ emulator::SimId, + images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader}, memory::{MemoryClient, MemoryView}, - vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader}, window::{ utils::{NumberEdit, UiExt as _}, AppWindow, @@ -20,17 +20,17 @@ use super::utils::{self, Object}; pub struct ObjectWindow { sim_id: SimId, - loader: Arc, + loader: Arc, memory: Arc, objects: MemoryView, index: usize, generic_palette: bool, - params: VramParams, + params: ImageParams, scale: f32, } impl ObjectWindow { - pub fn new(sim_id: SimId, memory: &Arc, vram: &mut VramProcessor) -> Self { + pub fn new(sim_id: SimId, memory: &Arc, images: &mut ImageProcessor) -> Self { let initial_params = ObjectParams { index: 0, generic_palette: false, @@ -38,9 +38,9 @@ impl ObjectWindow { right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), }; 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 = - VramTextureLoader::new([("vram://zoom".into(), zoom), ("vram://full".into(), full)]); + ImageTextureLoader::new([("vip://zoom".into(), zoom), ("vip://full".into(), full)]); Self { sim_id, 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) .texture_options(TextureOptions::NEAREST); ui.add(image); @@ -186,7 +186,7 @@ impl ObjectWindow { } 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) .texture_options(TextureOptions::NEAREST); 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 objects = self.objects.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; fn sizes(&self) -> [[usize; 2]; 2] { [[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(); self.render_object(&mut images[0], params, false, Eye::Left); self.render_object(&mut images[0], params, false, Eye::Right); diff --git a/src/window/vram/registers.rs b/src/window/vip/registers.rs similarity index 100% rename from src/window/vram/registers.rs rename to src/window/vip/registers.rs diff --git a/src/window/vram/utils.rs b/src/window/vip/utils.rs similarity index 100% rename from src/window/vram/utils.rs rename to src/window/vip/utils.rs diff --git a/src/window/vram/world.rs b/src/window/vip/world.rs similarity index 98% rename from src/window/vram/world.rs rename to src/window/vip/world.rs index 44258d0..c4c22a3 100644 --- a/src/window/vram/world.rs +++ b/src/window/vip/world.rs @@ -14,8 +14,8 @@ use num_traits::{FromPrimitive, ToPrimitive}; use crate::{ emulator::SimId, + images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader}, memory::{MemoryClient, MemoryRef, MemoryView}, - vram::{VramImage, VramParams, VramProcessor, VramRenderer, VramTextureLoader}, window::{ utils::{NumberEdit, UiExt as _}, AppWindow, @@ -26,19 +26,19 @@ use super::utils::{self, shade, CellData, Object}; pub struct WorldWindow { sim_id: SimId, - loader: Arc, + loader: Arc, memory: Arc, worlds: MemoryView, bgmaps: MemoryView, index: usize, param_index: usize, generic_palette: bool, - params: VramParams, + params: ImageParams, scale: f32, } impl WorldWindow { - pub fn new(sim_id: SimId, memory: &Arc, vram: &mut VramProcessor) -> Self { + pub fn new(sim_id: SimId, memory: &Arc, images: &mut ImageProcessor) -> Self { let initial_params = WorldParams { index: 31, generic_palette: false, @@ -46,8 +46,8 @@ impl WorldWindow { right_color: Color32::from_rgb(0x00, 0xc6, 0xf0), }; let renderer = WorldRenderer::new(sim_id, memory); - let ([world], params) = vram.add(renderer, initial_params); - let loader = VramTextureLoader::new([("vram://world".into(), world)]); + let ([world], params) = images.add(renderer, initial_params); + let loader = ImageTextureLoader::new([("vip://world".into(), world)]); Self { sim_id, loader: Arc::new(loader), @@ -423,7 +423,7 @@ impl WorldWindow { } 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) .texture_options(TextureOptions::NEAREST); 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() { *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(); 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; fn sizes(&self) -> [[usize; 2]; 1] { [[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 worlds = self.worlds.borrow();