PVB/lemur
PVB
/
lemur
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 36 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::{
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<MemoryClient>,
vram: VramProcessor,
images: ImageProcessor,
persistence: Persistence,
viewports: HashMap<ViewportId, Viewport>,
focused: Option<ViewportId>,
@ -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<UserEvent> 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) => {

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

@ -13,11 +13,11 @@ use egui::{
};
use tokio::{sync::mpsc, time::timeout};
pub struct VramProcessor {
sender: mpsc::UnboundedSender<Box<dyn VramRendererImpl>>,
pub struct ImageProcessor {
sender: mpsc::UnboundedSender<Box<dyn ImageRendererImpl>>,
}
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<const N: usize, R: VramRenderer<N> + 'static>(
pub fn add<const N: usize, R: ImageRenderer<N> + 'static>(
&self,
renderer: R,
params: R::Params,
) -> ([VramImageHandle; N], VramParams<R::Params>) {
let states = renderer.sizes().map(VramRenderImageState::new);
let handles = states.clone().map(|state| VramImageHandle {
) -> ([ImageHandle; N], ImageParams<R::Params>) {
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<Box<dyn VramRendererImpl>>,
renderers: Vec<Box<dyn VramRendererImpl>>,
struct ImageProcessorWorker {
receiver: mpsc::UnboundedReceiver<Box<dyn ImageRendererImpl>>,
renderers: Vec<Box<dyn ImageRendererImpl>>,
}
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<Color32>,
}
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<Mutex<Option<Arc<ColorImage>>>>,
}
impl VramImageHandle {
impl ImageHandle {
fn pull(&mut self) -> Option<Arc<ColorImage>> {
self.data.lock().unwrap().take()
}
}
pub struct VramParams<T> {
pub struct ImageParams<T> {
value: T,
sink: Arc<Mutex<T>>,
}
impl<T> Deref for VramParams<T> {
impl<T> Deref for ImageParams<T> {
type Target = T;
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) {
if self.value != value {
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;
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<ColorImage>; 2],
last_buffer: usize,
sink: Arc<Mutex<Option<Arc<ColorImage>>>>,
}
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<const N: usize, R: VramRenderer<N>> {
struct ImageRendererWrapper<const N: usize, R: ImageRenderer<N>> {
renderer: R,
params: Weak<Mutex<R::Params>>,
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<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<(), ()> {
let params = match self.params.upgrade() {
Some(params) => params.lock().unwrap().clone(),
@ -247,12 +247,12 @@ impl<const N: usize, R: VramRenderer<N> + Send> VramRendererImpl for VramRendere
}
}
pub struct VramTextureLoader {
cache: Mutex<HashMap<String, (VramImageHandle, Option<TextureHandle>)>>,
pub struct ImageTextureLoader {
cache: Mutex<HashMap<String, (ImageHandle, Option<TextureHandle>)>>,
}
impl VramTextureLoader {
pub fn new(renderers: impl IntoIterator<Item = (String, VramImageHandle)>) -> Self {
impl ImageTextureLoader {
pub fn new(renderers: impl IntoIterator<Item = (String, ImageHandle)>) -> 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(

2
src/main.rs
View File

@ -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)]

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:
* - 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

4
src/window.rs
View File

@ -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;

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::{
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<VramTextureLoader>,
loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>,
bgmaps: MemoryView,
cell_index: usize,
generic_palette: bool,
params: VramParams<BgMapParams>,
params: ImageParams<BgMapParams>,
scale: f32,
show_grid: bool,
}
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 ([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],

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

@ -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<VramTextureLoader>,
loader: Arc<ImageTextureLoader>,
brightness: MemoryView,
palettes: MemoryView,
palette: VramPalette,
palette: Palette,
index: usize,
params: VramParams<CharDataParams>,
params: ImageParams<CharDataParams>,
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::<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 {
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::{
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<VramTextureLoader>,
loader: Arc<ImageTextureLoader>,
index: usize,
left: bool,
right: bool,
generic_palette: bool,
params: VramParams<FrameBufferParams>,
params: ImageParams<FrameBufferParams>,
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();

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::{
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<VramTextureLoader>,
loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>,
objects: MemoryView,
index: usize,
generic_palette: bool,
params: VramParams<ObjectParams>,
params: ImageParams<ObjectParams>,
scale: f32,
}
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 {
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);

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::{
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<VramTextureLoader>,
loader: Arc<ImageTextureLoader>,
memory: Arc<MemoryClient>,
worlds: MemoryView,
bgmaps: MemoryView,
index: usize,
param_index: usize,
generic_palette: bool,
params: VramParams<WorldParams>,
params: ImageParams<WorldParams>,
scale: f32,
}
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 {
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();