Rename vram to vip internally
This commit is contained in:
parent
0ae2a2f54f
commit
6ab9d2ee53
20
src/app.rs
20
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<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) => {
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
@ -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)]
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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],
|
||||
|
|
@ -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));
|
||||
};
|
||||
|
|
@ -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();
|
||||
|
|
@ -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);
|
||||
|
|
@ -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();
|
||||
Loading…
Reference in New Issue