Compare commits
No commits in common. "main" and "profiling" have entirely different histories.
File diff suppressed because it is too large
Load Diff
21
Cargo.toml
21
Cargo.toml
|
|
@ -4,7 +4,7 @@ description = "An emulator for the Virtual Boy."
|
|||
repository = "https://git.virtual-boy.com/PVB/lemur"
|
||||
publish = false
|
||||
license = "MIT"
|
||||
version = "0.10.0"
|
||||
version = "0.7.3"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
|
@ -16,11 +16,11 @@ bytemuck = { version = "1", features = ["derive"] }
|
|||
clap = { version = "4", features = ["derive"] }
|
||||
cpal = { git = "https://github.com/sidit77/cpal.git", rev = "66ed6be" }
|
||||
directories = "6"
|
||||
egui = { version = "0.33", features = ["serde"] }
|
||||
egui_extras = { version = "0.33", features = ["image"] }
|
||||
egui-notify = "0.21"
|
||||
egui-winit = "0.33"
|
||||
egui-wgpu = { version = "0.33", features = ["winit"] }
|
||||
egui = { version = "0.32", features = ["serde"] }
|
||||
egui_extras = { version = "0.32", features = ["image"] }
|
||||
egui-notify = "0.20"
|
||||
egui-winit = "0.32"
|
||||
egui-wgpu = { version = "0.32", features = ["winit"] }
|
||||
fxprof-processed-profile = "0.8"
|
||||
fixed = { version = "1.28", features = ["num-traits"] }
|
||||
gilrs = { version = "0.11", features = ["serde-serialize"] }
|
||||
|
|
@ -29,10 +29,9 @@ hex = "0.4"
|
|||
image = { version = "0.25", default-features = false, features = ["png"] }
|
||||
itertools = "0.14"
|
||||
normpath = "1"
|
||||
notify = "8"
|
||||
num-derive = "0.4"
|
||||
num-traits = "0.2"
|
||||
object = "0.38"
|
||||
object = "0.37"
|
||||
oneshot = "0.1"
|
||||
pollster = "0.4"
|
||||
rand = "0.9"
|
||||
|
|
@ -41,16 +40,16 @@ rtrb = "0.3"
|
|||
rubato = "0.16"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
thread-priority = "3"
|
||||
thread-priority = "2"
|
||||
tokio = { version = "1", features = ["io-util", "macros", "net", "rt", "sync", "time"] }
|
||||
tracing = { version = "0.1", features = ["release_max_level_info"] }
|
||||
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
|
||||
wgpu = "27"
|
||||
wgpu = "25"
|
||||
wholesym = "0.8"
|
||||
winit = { version = "0.30", features = ["serde"] }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = ["Win32_System_Threading"] }
|
||||
windows = { version = "0.61", features = ["Win32_System_Threading"] }
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1"
|
||||
|
|
|
|||
|
|
@ -10,30 +10,30 @@ RUN apt-get update && \
|
|||
apt-get install -y ca-certificates
|
||||
COPY llvm.sources /etc/apt/sources.list.d/llvm.sources
|
||||
RUN apt-get update && \
|
||||
apt-get install -y bash bzip2 clang-21 git lld-21 llvm-21 make patch xz-utils && \
|
||||
ln -s $(which clang-21) /usr/bin/clang && \
|
||||
ln -s $(which clang++-21) /usr/bin/clang++ && \
|
||||
ln -s $(which ld64.lld-21) /usr/bin/ld64.lld && \
|
||||
apt-get install -y bash bzip2 clang-20 git lld-20 llvm-20 make patch xz-utils && \
|
||||
ln -s $(which clang-20) /usr/bin/clang && \
|
||||
ln -s $(which clang++-20) /usr/bin/clang++ && \
|
||||
ln -s $(which ld64.lld-20) /usr/bin/ld64.lld && \
|
||||
SDK_VERSION=14.5 UNATTENDED=1 ENABLE_COMPILER_RT_INSTALL=1 TARGET_DIR=/osxcross ./build.sh
|
||||
|
||||
FROM rust:1.91-bookworm
|
||||
FROM rust:1.89-bookworm
|
||||
ADD --chmod=644 "https://apt.llvm.org/llvm-snapshot.gpg.key" /etc/apt/trusted.gpg.d/apt.llvm.org.asc
|
||||
COPY llvm.sources /etc/apt/sources.list.d/llvm.sources
|
||||
RUN rustup target add x86_64-pc-windows-msvc && \
|
||||
rustup target add x86_64-apple-darwin && \
|
||||
rustup target add aarch64-apple-darwin && \
|
||||
apt-get update && \
|
||||
apt-get install -y clang-21 lld-21 libc6-dev libasound2-dev libudev-dev genisoimage mingw-w64 && \
|
||||
apt-get install -y clang-20 lld-20 libc6-dev libasound2-dev libudev-dev genisoimage mingw-w64 && \
|
||||
cargo install cargo-bundle xwin && \
|
||||
xwin --accept-license splat --output xwin && \
|
||||
rm -rf .xwin-cache && \
|
||||
ln -s $(which clang-21) /usr/bin/clang && \
|
||||
ln -s $(which clang++-21) /usr/bin/clang++
|
||||
ln -s $(which clang-20) /usr/bin/clang && \
|
||||
ln -s $(which clang++-20) /usr/bin/clang++
|
||||
COPY --from=osxcross /osxcross /osxcross
|
||||
|
||||
ENV PATH="/osxcross/bin:$PATH" \
|
||||
LD_LIBRARY_PATH="/osxcross/lib" \
|
||||
CC="clang-21" CXX="clang++-21" AR="llvm-ar-21" \
|
||||
CC="clang-20" CXX="clang++-20" AR="llvm-ar-20" \
|
||||
CC_x86_64-apple-darwin="o64-clang" \
|
||||
CXX_x86_64-apple-darwin="o64-clang++" \
|
||||
CC_aarch64-apple-darwin="oa64-clang" \
|
||||
|
|
@ -41,13 +41,12 @@ ENV PATH="/osxcross/bin:$PATH" \
|
|||
SHROOMS_CFLAGS_x86_64-unknown-linux-gnu="-flto" \
|
||||
CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS="-Clinker-plugin-lto -Clinker=clang -Clink-arg=-fuse-ld=lld" \
|
||||
SHROOMS_CFLAGS_x86_64-pc-windows-msvc="-flto" \
|
||||
CFLAGS_x86_64-pc-windows-msvc="-I/xwin/crt/include -I/xwin/sdk/include/ucrt -I/xwin/sdk/include/um -I/xwin/sdk/include/shared" \
|
||||
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_RUSTFLAGS="-Lnative=/xwin/crt/lib/x86_64 -Lnative=/xwin/sdk/lib/um/x86_64 -Lnative=/xwin/sdk/lib/ucrt/x86_64 -Clinker-plugin-lto -Clink-arg=-fuse-ld=lld" \
|
||||
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER="lld-link-21" \
|
||||
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER="lld-link-20" \
|
||||
CARGO_TARGET_X86_64_APPLE_DARWIN_LINKER="o64-clang" \
|
||||
CARGO_TARGET_X86_64_APPLE_DARWIN_AR="llvm-ar-21" \
|
||||
CARGO_TARGET_X86_64_APPLE_DARWIN_AR="llvm-ar-20" \
|
||||
CARGO_TARGET_AARCH64_APPLE_DARWIN_LINKER="oa64-clang" \
|
||||
CARGO_TARGET_AARCH64_APPLE_DARWIN_AR="llvm-ar-21" \
|
||||
RC_PATH="llvm-rc-21" \
|
||||
CARGO_TARGET_AARCH64_APPLE_DARWIN_AR="llvm-ar-20" \
|
||||
RC_PATH="llvm-rc-20" \
|
||||
MACOSX_DEPLOYMENT_TARGET="14.5"
|
||||
ENTRYPOINT ["bash"]
|
||||
|
|
|
|||
5
build.rs
5
build.rs
|
|
@ -18,10 +18,8 @@ fn main() -> Result<(), Box<dyn Error>> {
|
|||
};
|
||||
builder
|
||||
.include(Path::new("shrooms-vb-core/core"))
|
||||
.include(Path::new("shrooms-vb-core/util"))
|
||||
.opt_level(opt_level)
|
||||
.flag_if_supported("-fno-strict-aliasing")
|
||||
.define("_CRT_SECURE_NO_WARNINGS", None)
|
||||
.define("VB_LITTLE_ENDIAN", None)
|
||||
.define("VB_SIGNED_PROPAGATE", None)
|
||||
.define("VB_DIV_GENERIC", None)
|
||||
|
|
@ -31,10 +29,7 @@ fn main() -> Result<(), Box<dyn Error>> {
|
|||
.define("VB_DIRECT_FRAME", "on_frame")
|
||||
.define("VB_DIRECT_READ", "on_read")
|
||||
.define("VB_DIRECT_WRITE", "on_write")
|
||||
.define("VBU_REALLOC", "vbu_realloc_shim")
|
||||
.file(Path::new("shrooms-vb-core/core/vb.c"))
|
||||
.file(Path::new("shrooms-vb-core/util/isx.c"))
|
||||
.file(Path::new("shrooms-vb-core/util/vbu.c"))
|
||||
.compile("vb");
|
||||
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
Types: deb deb-src
|
||||
URIs: http://apt.llvm.org/bookworm/
|
||||
Suites: llvm-toolchain-bookworm-21
|
||||
Suites: llvm-toolchain-bookworm-20
|
||||
Components: main
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 534ce852f46f1deba9014971b1bae29e974984d7
|
||||
Subproject commit 8598eab087cced12b92a411f6c7f2eb9de51310f
|
||||
78
src/app.rs
78
src/app.rs
|
|
@ -16,7 +16,6 @@ use winit::{
|
|||
};
|
||||
|
||||
use crate::{
|
||||
config::CliArgs,
|
||||
controller::ControllerManager,
|
||||
emulator::{EmulatorClient, EmulatorCommand, SimId},
|
||||
images::ImageProcessor,
|
||||
|
|
@ -25,8 +24,8 @@ use crate::{
|
|||
persistence::Persistence,
|
||||
window::{
|
||||
AboutWindow, AppWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, GameWindow,
|
||||
GdbServerWindow, HotkeysWindow, InitArgs, InputWindow, ObjectWindow, ProfileWindow,
|
||||
RegisterWindow, TerminalWindow, WorldWindow,
|
||||
GdbServerWindow, HotkeysWindow, InputWindow, ObjectWindow, ProfileWindow, RegisterWindow,
|
||||
TerminalWindow, WorldWindow,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
@ -56,24 +55,18 @@ pub struct Application {
|
|||
focused: Option<ViewportId>,
|
||||
init_debug_port: Option<u16>,
|
||||
init_profiling: bool,
|
||||
init_bgmap: bool,
|
||||
init_chardata: bool,
|
||||
init_objects: bool,
|
||||
init_worlds: bool,
|
||||
init_framebuffers: bool,
|
||||
init_registers: bool,
|
||||
init_terminal: bool,
|
||||
}
|
||||
|
||||
impl Application {
|
||||
pub fn new(
|
||||
client: EmulatorClient,
|
||||
proxy: EventLoopProxy<UserEvent>,
|
||||
persistence: Persistence,
|
||||
args: CliArgs,
|
||||
debug_port: Option<u16>,
|
||||
profiling: bool,
|
||||
) -> Self {
|
||||
let wgpu = WgpuState::new();
|
||||
let icon = load_icon().ok().map(Arc::new);
|
||||
let persistence = Persistence::new();
|
||||
let mappings = MappingProvider::new(persistence.clone());
|
||||
let shortcuts = ShortcutProvider::new(persistence.clone());
|
||||
let controllers = ControllerManager::new(client.clone(), &mappings);
|
||||
|
|
@ -97,15 +90,8 @@ impl Application {
|
|||
persistence,
|
||||
viewports: HashMap::new(),
|
||||
focused: None,
|
||||
init_debug_port: args.debug_port,
|
||||
init_profiling: args.profile,
|
||||
init_bgmap: args.bgmap_data,
|
||||
init_chardata: args.character_data,
|
||||
init_objects: args.object_data,
|
||||
init_worlds: args.worlds,
|
||||
init_framebuffers: args.frame_buffers,
|
||||
init_registers: args.registers,
|
||||
init_terminal: args.terminal,
|
||||
init_debug_port: debug_port,
|
||||
init_profiling: profiling,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -138,40 +124,11 @@ impl ApplicationHandler<UserEvent> for Application {
|
|||
SimId::Player1,
|
||||
);
|
||||
self.open(event_loop, Box::new(app));
|
||||
let sim_id = SimId::Player1;
|
||||
if self.init_profiling {
|
||||
let mut profiler = ProfileWindow::new(sim_id, self.client.clone());
|
||||
let mut profiler = ProfileWindow::new(SimId::Player1, self.client.clone());
|
||||
profiler.launch();
|
||||
self.open(event_loop, Box::new(profiler));
|
||||
}
|
||||
if self.init_chardata {
|
||||
let chardata = CharacterDataWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(chardata));
|
||||
}
|
||||
if self.init_bgmap {
|
||||
let bgmap = BgMapWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(bgmap));
|
||||
}
|
||||
if self.init_objects {
|
||||
let objects = ObjectWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(objects));
|
||||
}
|
||||
if self.init_worlds {
|
||||
let world = WorldWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(world));
|
||||
}
|
||||
if self.init_framebuffers {
|
||||
let fb = FrameBufferWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(fb));
|
||||
}
|
||||
if self.init_registers {
|
||||
let registers = RegisterWindow::new(sim_id, &self.memory);
|
||||
self.open(event_loop, Box::new(registers));
|
||||
}
|
||||
if self.init_terminal {
|
||||
let terminal = TerminalWindow::new(sim_id, &self.client);
|
||||
self.open(event_loop, Box::new(terminal));
|
||||
}
|
||||
}
|
||||
|
||||
fn window_event(
|
||||
|
|
@ -287,8 +244,8 @@ impl ApplicationHandler<UserEvent> for Application {
|
|||
self.open(event_loop, Box::new(world));
|
||||
}
|
||||
UserEvent::OpenFrameBuffers(sim_id) => {
|
||||
let fb = FrameBufferWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(fb));
|
||||
let world = FrameBufferWindow::new(sim_id, &self.memory, &mut self.images);
|
||||
self.open(event_loop, Box::new(world));
|
||||
}
|
||||
UserEvent::OpenRegisters(sim_id) => {
|
||||
let registers = RegisterWindow::new(sim_id, &self.memory);
|
||||
|
|
@ -449,12 +406,13 @@ impl Viewport {
|
|||
..egui_wgpu::WgpuConfiguration::default()
|
||||
};
|
||||
|
||||
let options = egui_wgpu::RendererOptions::default();
|
||||
let mut painter = pollster::block_on(egui_wgpu::winit::Painter::new(
|
||||
ctx.clone(),
|
||||
wgpu_config,
|
||||
1,
|
||||
None,
|
||||
false,
|
||||
options,
|
||||
true,
|
||||
));
|
||||
|
||||
let mut info = ViewportInfo::default();
|
||||
|
|
@ -465,13 +423,7 @@ impl Viewport {
|
|||
let (window, state) = create_window_and_state(&ctx, event_loop, &builder, &mut painter);
|
||||
egui_winit::update_viewport_info(&mut info, &ctx, &window, true);
|
||||
|
||||
let render_state = painter.render_state();
|
||||
let args = InitArgs {
|
||||
ctx: &ctx,
|
||||
window: &window,
|
||||
render_state: render_state.as_ref().unwrap(),
|
||||
};
|
||||
app.on_init(args);
|
||||
app.on_init(&ctx, painter.render_state().as_ref().unwrap());
|
||||
Self {
|
||||
painter,
|
||||
ctx,
|
||||
|
|
@ -553,7 +505,7 @@ impl Viewport {
|
|||
&mut self.info,
|
||||
std::mem::take(&mut self.commands),
|
||||
&self.window,
|
||||
&mut vec![],
|
||||
&mut HashSet::default(),
|
||||
);
|
||||
|
||||
if self.info.close_requested() {
|
||||
|
|
|
|||
|
|
@ -1,96 +0,0 @@
|
|||
use anyhow::Result;
|
||||
use clap::Parser;
|
||||
use egui::{Color32, Vec2};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{emulator::SimId, persistence::Persistence, window::DisplayMode};
|
||||
use std::path::PathBuf;
|
||||
|
||||
#[derive(Parser)]
|
||||
pub struct CliArgs {
|
||||
/// The path to a virtual boy ROM to run.
|
||||
pub rom: Option<PathBuf>,
|
||||
/// Start a GDB/LLDB debug server on this port.
|
||||
#[arg(short, long)]
|
||||
pub debug_port: Option<u16>,
|
||||
/// Enable profiling a game
|
||||
#[arg(short, long)]
|
||||
pub profile: bool,
|
||||
/// Open character data window
|
||||
#[arg(short, long)]
|
||||
pub character_data: bool,
|
||||
/// Open bgmap data window
|
||||
#[arg(short, long)]
|
||||
pub bgmap_data: bool,
|
||||
/// Open object data window
|
||||
#[arg(short, long)]
|
||||
pub object_data: bool,
|
||||
/// Open worlds window
|
||||
#[arg(long)]
|
||||
pub worlds: bool,
|
||||
/// Open frame buffers window
|
||||
#[arg(short, long)]
|
||||
pub frame_buffers: bool,
|
||||
/// Open registers window
|
||||
#[arg(short, long)]
|
||||
pub registers: bool,
|
||||
/// Open terminal
|
||||
#[arg(short, long)]
|
||||
pub terminal: bool,
|
||||
/// Watch ROM files for changes, automatically reload
|
||||
#[arg(short, long)]
|
||||
pub watch: bool,
|
||||
}
|
||||
|
||||
pub const COLOR_PRESETS: [[Color32; 2]; 3] = [
|
||||
[
|
||||
Color32::from_rgb(0xff, 0x00, 0x00),
|
||||
Color32::from_rgb(0x00, 0xc6, 0xf0),
|
||||
],
|
||||
[
|
||||
Color32::from_rgb(0x00, 0xb4, 0x00),
|
||||
Color32::from_rgb(0xc8, 0x00, 0xff),
|
||||
],
|
||||
[
|
||||
Color32::from_rgb(0xb4, 0x9b, 0x00),
|
||||
Color32::from_rgb(0x00, 0x00, 0xff),
|
||||
],
|
||||
];
|
||||
|
||||
const fn default_audio_enabled() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||||
pub struct SimConfig {
|
||||
pub display_mode: DisplayMode,
|
||||
pub colors: [Color32; 2],
|
||||
pub dimensions: Vec2,
|
||||
#[serde(default = "default_audio_enabled")]
|
||||
pub audio_enabled: bool,
|
||||
}
|
||||
|
||||
impl SimConfig {
|
||||
pub fn load(persistence: &Persistence, sim_id: SimId) -> Self {
|
||||
if let Ok(config) = persistence.load_config(config_filename(sim_id)) {
|
||||
return config;
|
||||
}
|
||||
Self {
|
||||
display_mode: DisplayMode::Anaglyph,
|
||||
colors: COLOR_PRESETS[0],
|
||||
dimensions: DisplayMode::Anaglyph.proportions() + Vec2::new(0.0, 22.0),
|
||||
audio_enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save(&self, persistence: &Persistence, sim_id: SimId) -> Result<()> {
|
||||
persistence.save_config(config_filename(sim_id), self)
|
||||
}
|
||||
}
|
||||
|
||||
fn config_filename(sim_id: SimId) -> &'static str {
|
||||
match sim_id {
|
||||
SimId::Player1 => "config_p1",
|
||||
SimId::Player2 => "config_p2",
|
||||
}
|
||||
}
|
||||
132
src/emulator.rs
132
src/emulator.rs
|
|
@ -5,7 +5,7 @@ use std::{
|
|||
sync::{
|
||||
Arc, Weak,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc::{self, RecvTimeoutError, TryRecvError},
|
||||
mpsc::{self, RecvError, TryRecvError},
|
||||
},
|
||||
time::Duration,
|
||||
};
|
||||
|
|
@ -33,7 +33,6 @@ mod cart;
|
|||
mod game_info;
|
||||
mod inline_stack_map;
|
||||
mod shrooms_vb_core;
|
||||
mod shrooms_vb_util;
|
||||
|
||||
#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
|
||||
pub enum SimId {
|
||||
|
|
@ -75,7 +74,6 @@ pub struct EmulatorBuilder {
|
|||
audio_on: Arc<[AtomicBool; 2]>,
|
||||
linked: Arc<AtomicBool>,
|
||||
start_paused: bool,
|
||||
watch_rom: Arc<[AtomicBool; 2]>,
|
||||
}
|
||||
|
||||
impl EmulatorBuilder {
|
||||
|
|
@ -92,13 +90,12 @@ impl EmulatorBuilder {
|
|||
audio_on: Arc::new([AtomicBool::new(true), AtomicBool::new(true)]),
|
||||
linked: Arc::new(AtomicBool::new(false)),
|
||||
start_paused: false,
|
||||
watch_rom: Arc::new([AtomicBool::new(false), AtomicBool::new(false)]),
|
||||
};
|
||||
let client = EmulatorClient {
|
||||
queue,
|
||||
sim_state: builder.sim_state.clone(),
|
||||
state: builder.state.clone(),
|
||||
watch_rom: builder.watch_rom.clone(),
|
||||
audio_on: builder.audio_on.clone(),
|
||||
linked: builder.linked.clone(),
|
||||
};
|
||||
(builder, client)
|
||||
|
|
@ -118,25 +115,12 @@ impl EmulatorBuilder {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn with_audio_on(self, p1: bool, p2: bool) -> Self {
|
||||
self.audio_on[0].store(p1, Ordering::Relaxed);
|
||||
self.audio_on[1].store(p2, Ordering::Relaxed);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_watch_rom(self, p1: bool, p2: bool) -> Self {
|
||||
self.watch_rom[0].store(p1, Ordering::Relaxed);
|
||||
self.watch_rom[1].store(p2, Ordering::Relaxed);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn build(self) -> Result<Emulator> {
|
||||
let mut emulator = Emulator::new(
|
||||
self.commands,
|
||||
self.sim_state,
|
||||
self.state,
|
||||
self.audio_on,
|
||||
self.watch_rom,
|
||||
self.linked,
|
||||
)?;
|
||||
if let Some(path) = self.rom {
|
||||
|
|
@ -157,7 +141,6 @@ pub struct Emulator {
|
|||
sim_state: Arc<[Atomic<SimState>; 2]>,
|
||||
state: Arc<Atomic<EmulatorState>>,
|
||||
audio_on: Arc<[AtomicBool; 2]>,
|
||||
watch_rom: Arc<[AtomicBool; 2]>,
|
||||
linked: Arc<AtomicBool>,
|
||||
profilers: [Option<ProfileSender>; 2],
|
||||
renderers: HashMap<SimId, TextureSink>,
|
||||
|
|
@ -176,7 +159,6 @@ impl Emulator {
|
|||
sim_state: Arc<[Atomic<SimState>; 2]>,
|
||||
state: Arc<Atomic<EmulatorState>>,
|
||||
audio_on: Arc<[AtomicBool; 2]>,
|
||||
watch_rom: Arc<[AtomicBool; 2]>,
|
||||
linked: Arc<AtomicBool>,
|
||||
) -> Result<Self> {
|
||||
Ok(Self {
|
||||
|
|
@ -187,7 +169,6 @@ impl Emulator {
|
|||
sim_state,
|
||||
state,
|
||||
audio_on,
|
||||
watch_rom,
|
||||
linked,
|
||||
profilers: [None, None],
|
||||
renderers: HashMap::new(),
|
||||
|
|
@ -201,18 +182,9 @@ impl Emulator {
|
|||
})
|
||||
}
|
||||
|
||||
pub fn reload_cart(&mut self, sim_id: SimId) -> Result<()> {
|
||||
let Some(cart) = &self.carts[sim_id.to_index()] else {
|
||||
return Ok(());
|
||||
};
|
||||
let path = cart.file_path.clone();
|
||||
self.load_cart(sim_id, &path)
|
||||
}
|
||||
|
||||
pub fn load_cart(&mut self, sim_id: SimId, path: &Path) -> Result<()> {
|
||||
let watch = self.watch_rom[sim_id.to_index()].load(Ordering::Acquire);
|
||||
let cart = Cart::load(path, sim_id, watch)?;
|
||||
self.try_reset_sim(sim_id, Some(cart))?;
|
||||
let cart = Cart::load(path, sim_id)?;
|
||||
self.reset_sim(sim_id, Some(cart))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -222,26 +194,16 @@ impl Emulator {
|
|||
} else {
|
||||
self.carts[0].as_ref().map(|c| c.file_path.clone())
|
||||
};
|
||||
let watch = self.watch_rom[SimId::Player2.to_index()].load(Ordering::Acquire);
|
||||
let cart = match file_path {
|
||||
Some(rom_path) => Some(Cart::load(&rom_path, SimId::Player2, watch)?),
|
||||
Some(rom_path) => Some(Cart::load(&rom_path, SimId::Player2)?),
|
||||
None => None,
|
||||
};
|
||||
self.try_reset_sim(SimId::Player2, cart)?;
|
||||
self.reset_sim(SimId::Player2, cart)?;
|
||||
self.link_sims();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn reset_sim(&mut self, sim_id: SimId, new_cart: Option<Cart>) -> bool {
|
||||
if let Err(error) = self.try_reset_sim(sim_id, new_cart) {
|
||||
self.report_error(sim_id, format!("Error resetting sim: {error}"));
|
||||
false
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
fn try_reset_sim(&mut self, sim_id: SimId, new_cart: Option<Cart>) -> Result<()> {
|
||||
fn reset_sim(&mut self, sim_id: SimId, new_cart: Option<Cart>) -> Result<()> {
|
||||
self.save_sram(sim_id)?;
|
||||
|
||||
let index = sim_id.to_index();
|
||||
|
|
@ -262,10 +224,6 @@ impl Emulator {
|
|||
sim.load_cart(cart.rom.clone(), cart.sram.clone())?;
|
||||
self.carts[index] = Some(cart);
|
||||
self.sim_state[index].store(SimState::Ready, Ordering::Release);
|
||||
} else if let Some(cart) = self.carts[index].as_mut()
|
||||
&& cart.is_watching()
|
||||
{
|
||||
cart.restart_watching();
|
||||
}
|
||||
let mut profiling = false;
|
||||
if let Some(profiler) = self.profilers[sim_id.to_index()].as_ref()
|
||||
|
|
@ -382,7 +340,7 @@ impl Emulator {
|
|||
|
||||
fn start_profiling(&mut self, sim_id: SimId, sender: ProfileSender) -> Result<()> {
|
||||
self.profilers[sim_id.to_index()] = Some(sender);
|
||||
self.try_reset_sim(sim_id, None)
|
||||
self.reset_sim(sim_id, None)
|
||||
}
|
||||
|
||||
fn start_debugging(&mut self, sim_id: SimId, sender: DebugSender) {
|
||||
|
|
@ -458,30 +416,11 @@ impl Emulator {
|
|||
let idle = self.tick();
|
||||
if idle {
|
||||
// The game is paused, and we have output all the video/audio we have.
|
||||
// Block the thread until a new command comes in, or a ROM changes.
|
||||
loop {
|
||||
match self.commands.recv_timeout(Duration::from_millis(250)) {
|
||||
Ok(command) => {
|
||||
self.handle_command(command);
|
||||
break;
|
||||
}
|
||||
Err(RecvTimeoutError::Timeout) => {
|
||||
let mut changed = false;
|
||||
for sim_id in SimId::values() {
|
||||
let Some(cart) = self.carts[sim_id.to_index()].as_ref() else {
|
||||
continue;
|
||||
};
|
||||
if cart.changed() {
|
||||
changed |= self.reset_sim(sim_id, None);
|
||||
}
|
||||
}
|
||||
if changed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(RecvTimeoutError::Disconnected) => {
|
||||
return;
|
||||
}
|
||||
// Block the thread until a new command comes in.
|
||||
match self.commands.recv() {
|
||||
Ok(command) => self.handle_command(command),
|
||||
Err(RecvError) => {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -496,14 +435,6 @@ impl Emulator {
|
|||
}
|
||||
}
|
||||
}
|
||||
for sim_id in SimId::values() {
|
||||
let Some(cart) = self.carts[sim_id.to_index()].as_ref() else {
|
||||
continue;
|
||||
};
|
||||
if cart.changed() {
|
||||
self.reset_sim(sim_id, None);
|
||||
}
|
||||
}
|
||||
self.watched_regions.retain(|range, region| {
|
||||
let Some(region) = region.upgrade() else {
|
||||
return false;
|
||||
|
|
@ -670,22 +601,6 @@ impl Emulator {
|
|||
self.report_error(sim_id, format!("Error loading rom: {error}"));
|
||||
}
|
||||
}
|
||||
EmulatorCommand::ReloadRom(sim_id) => {
|
||||
if let Err(error) = self.reload_cart(sim_id) {
|
||||
self.report_error(sim_id, format!("Error loading rom: {error}"));
|
||||
}
|
||||
}
|
||||
EmulatorCommand::WatchRom(sim_id, watch) => {
|
||||
self.watch_rom[sim_id.to_index()].store(watch, Ordering::Release);
|
||||
let Some(cart) = self.carts[sim_id.to_index()].as_mut() else {
|
||||
return;
|
||||
};
|
||||
if watch {
|
||||
cart.restart_watching();
|
||||
} else {
|
||||
cart.stop_watching();
|
||||
}
|
||||
}
|
||||
EmulatorCommand::StartSecondSim(path) => {
|
||||
if let Err(error) = self.start_second_sim(path) {
|
||||
self.report_error(
|
||||
|
|
@ -799,8 +714,9 @@ impl Emulator {
|
|||
};
|
||||
sim.watch_stdout(true);
|
||||
}
|
||||
EmulatorCommand::SetAudioEnabled(sim_id, enabled) => {
|
||||
self.audio_on[sim_id.to_index()].store(enabled, Ordering::Release);
|
||||
EmulatorCommand::SetAudioEnabled(p1, p2) => {
|
||||
self.audio_on[SimId::Player1.to_index()].store(p1, Ordering::Release);
|
||||
self.audio_on[SimId::Player2.to_index()].store(p2, Ordering::Release);
|
||||
}
|
||||
EmulatorCommand::Link => {
|
||||
self.link_sims();
|
||||
|
|
@ -809,7 +725,9 @@ impl Emulator {
|
|||
self.unlink_sims();
|
||||
}
|
||||
EmulatorCommand::Reset(sim_id) => {
|
||||
self.reset_sim(sim_id, None);
|
||||
if let Err(error) = self.reset_sim(sim_id, None) {
|
||||
self.report_error(sim_id, format!("Error resetting sim: {error}"));
|
||||
}
|
||||
}
|
||||
EmulatorCommand::SetKeys(sim_id, keys) => {
|
||||
if let Some(sim) = self.sims.get_mut(sim_id.to_index()) {
|
||||
|
|
@ -851,8 +769,6 @@ impl Emulator {
|
|||
pub enum EmulatorCommand {
|
||||
ConnectToSim(SimId, TextureSink, mpsc::Sender<Toast>),
|
||||
LoadGame(SimId, PathBuf),
|
||||
ReloadRom(SimId),
|
||||
WatchRom(SimId, bool),
|
||||
StartSecondSim(Option<PathBuf>),
|
||||
StopSecondSim,
|
||||
Pause,
|
||||
|
|
@ -875,7 +791,7 @@ pub enum EmulatorCommand {
|
|||
AddWatchpoint(SimId, u32, usize, VBWatchpointType),
|
||||
RemoveWatchpoint(SimId, u32, usize, VBWatchpointType),
|
||||
WatchStdout(SimId, mpsc::Sender<String>),
|
||||
SetAudioEnabled(SimId, bool),
|
||||
SetAudioEnabled(bool, bool),
|
||||
Link,
|
||||
Unlink,
|
||||
Reset(SimId),
|
||||
|
|
@ -941,8 +857,8 @@ pub struct EmulatorClient {
|
|||
queue: mpsc::Sender<EmulatorCommand>,
|
||||
sim_state: Arc<[Atomic<SimState>; 2]>,
|
||||
state: Arc<Atomic<EmulatorState>>,
|
||||
audio_on: Arc<[AtomicBool; 2]>,
|
||||
linked: Arc<AtomicBool>,
|
||||
watch_rom: Arc<[AtomicBool; 2]>,
|
||||
}
|
||||
|
||||
impl EmulatorClient {
|
||||
|
|
@ -952,12 +868,12 @@ impl EmulatorClient {
|
|||
pub fn emulator_state(&self) -> EmulatorState {
|
||||
self.state.load(Ordering::Acquire)
|
||||
}
|
||||
pub fn is_audio_enabled(&self, sim_id: SimId) -> bool {
|
||||
self.audio_on[sim_id.to_index()].load(Ordering::Acquire)
|
||||
}
|
||||
pub fn are_sims_linked(&self) -> bool {
|
||||
self.linked.load(Ordering::Acquire)
|
||||
}
|
||||
pub fn is_rom_watched(&self, sim_id: SimId) -> bool {
|
||||
self.watch_rom[sim_id.to_index()].load(Ordering::Acquire)
|
||||
}
|
||||
pub fn send_command(&self, command: EmulatorCommand) -> bool {
|
||||
match self.queue.send(command) {
|
||||
Ok(()) => true,
|
||||
|
|
|
|||
|
|
@ -1,14 +1,13 @@
|
|||
use anyhow::Result;
|
||||
use notify::Watcher;
|
||||
use rand::Rng;
|
||||
use std::{
|
||||
fs::{self, File},
|
||||
io::{Read, Seek as _, SeekFrom, Write as _},
|
||||
path::{Path, PathBuf},
|
||||
sync::{Arc, atomic::AtomicBool},
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use crate::emulator::{SimId, game_info::GameInfo, shrooms_vb_util::rom_from_isx};
|
||||
use crate::emulator::{SimId, game_info::GameInfo};
|
||||
|
||||
pub struct Cart {
|
||||
pub file_path: PathBuf,
|
||||
|
|
@ -16,16 +15,13 @@ pub struct Cart {
|
|||
sram_file: File,
|
||||
pub sram: Vec<u8>,
|
||||
pub info: Arc<GameInfo>,
|
||||
watcher: Option<notify::RecommendedWatcher>,
|
||||
changed: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl Cart {
|
||||
pub fn load(file_path: &Path, sim_id: SimId, watch: bool) -> Result<Self> {
|
||||
pub fn load(file_path: &Path, sim_id: SimId) -> Result<Self> {
|
||||
let rom = fs::read(file_path)?;
|
||||
let (rom, info) = try_parse_isx(file_path, &rom)
|
||||
.or_else(|| try_parse_elf(file_path, &rom))
|
||||
.unwrap_or_else(|| (rom, GameInfo::empty(file_path)));
|
||||
let (rom, info) =
|
||||
try_parse_elf(file_path, &rom).unwrap_or_else(|| (rom, GameInfo::empty(file_path)));
|
||||
|
||||
let mut sram_file = File::options()
|
||||
.read(true)
|
||||
|
|
@ -48,21 +44,12 @@ impl Cart {
|
|||
sram
|
||||
};
|
||||
|
||||
let changed = Arc::new(AtomicBool::new(false));
|
||||
let watcher = if watch {
|
||||
build_watcher(file_path, changed.clone())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
Ok(Cart {
|
||||
file_path: file_path.to_path_buf(),
|
||||
rom,
|
||||
sram_file,
|
||||
sram,
|
||||
info: Arc::new(info),
|
||||
watcher,
|
||||
changed,
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -71,56 +58,6 @@ impl Cart {
|
|||
self.sram_file.write_all(&self.sram)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn changed(&self) -> bool {
|
||||
self.changed.load(std::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
|
||||
pub fn is_watching(&self) -> bool {
|
||||
self.watcher.is_some()
|
||||
}
|
||||
|
||||
pub fn restart_watching(&mut self) {
|
||||
self.changed = Arc::new(AtomicBool::new(false));
|
||||
if let Some(mut watcher) = self.watcher.take() {
|
||||
let _ = watcher.unwatch(&self.file_path);
|
||||
};
|
||||
self.watcher = build_watcher(&self.file_path, self.changed.clone());
|
||||
}
|
||||
|
||||
pub fn stop_watching(&mut self) {
|
||||
self.changed = Arc::new(AtomicBool::new(false));
|
||||
self.watcher = None;
|
||||
}
|
||||
}
|
||||
|
||||
fn build_watcher(file_path: &Path, changed: Arc<AtomicBool>) -> Option<notify::RecommendedWatcher> {
|
||||
let file_path = file_path.to_path_buf();
|
||||
let mut watcher =
|
||||
notify::recommended_watcher(move |event: Result<notify::Event, notify::Error>| {
|
||||
let Ok(e) = event else {
|
||||
return;
|
||||
};
|
||||
let modified = !matches!(
|
||||
e.kind,
|
||||
notify::EventKind::Access(_)
|
||||
| notify::EventKind::Modify(notify::event::ModifyKind::Metadata(_))
|
||||
);
|
||||
if modified {
|
||||
changed.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
})
|
||||
.ok()?;
|
||||
watcher
|
||||
.watch(&file_path, notify::RecursiveMode::NonRecursive)
|
||||
.ok()?;
|
||||
Some(watcher)
|
||||
}
|
||||
|
||||
fn try_parse_isx(file_path: &Path, data: &[u8]) -> Option<(Vec<u8>, GameInfo)> {
|
||||
let rom = rom_from_isx(data)?;
|
||||
let info = GameInfo::from_isx(file_path, data);
|
||||
Some((rom, info))
|
||||
}
|
||||
|
||||
fn try_parse_elf(file_path: &Path, data: &[u8]) -> Option<(Vec<u8>, GameInfo)> {
|
||||
|
|
@ -136,7 +73,7 @@ fn try_parse_elf(file_path: &Path, data: &[u8]) -> Option<(Vec<u8>, GameInfo)> {
|
|||
}
|
||||
_ => return None,
|
||||
};
|
||||
let info = GameInfo::from_elf(file_path, data).unwrap_or_else(|_| GameInfo::empty(file_path));
|
||||
let info = GameInfo::new(file_path, data).unwrap_or_else(|_| GameInfo::empty(file_path));
|
||||
Some((program, info))
|
||||
}
|
||||
|
||||
|
|
@ -149,13 +86,12 @@ fn parse_elf_program<Elf: object::read::elf::FileHeader<Endian = object::Endiann
|
|||
let mut bytes = vec![];
|
||||
let mut pstart = None;
|
||||
for phdr in header.program_headers(endian, data).ok()? {
|
||||
let pma = phdr.p_paddr(endian).into();
|
||||
if pma < 0x07000000 || phdr.p_filesz(endian).into() == 0 {
|
||||
if phdr.p_filesz(endian).into() == 0 {
|
||||
continue;
|
||||
}
|
||||
let start = pstart.unwrap_or(pma);
|
||||
let start = pstart.unwrap_or(phdr.p_paddr(endian).into());
|
||||
pstart = Some(start);
|
||||
bytes.resize((pma - start) as usize, 0);
|
||||
bytes.resize((phdr.p_paddr(endian).into() - start) as usize, 0);
|
||||
let data = phdr.data(endian, data).ok()?;
|
||||
bytes.extend_from_slice(data);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ pub struct GameInfo {
|
|||
}
|
||||
|
||||
impl GameInfo {
|
||||
pub fn from_elf(file_path: &Path, input: &[u8]) -> Result<Self> {
|
||||
pub fn new(file_path: &Path, input: &[u8]) -> Result<Self> {
|
||||
let file = object::File::parse(input)?;
|
||||
|
||||
let (name, path) = name_and_path(file_path);
|
||||
|
|
@ -52,26 +52,6 @@ impl GameInfo {
|
|||
})
|
||||
}
|
||||
|
||||
pub fn from_isx(file_path: &Path, input: &[u8]) -> Self {
|
||||
let (name, path) = name_and_path(file_path);
|
||||
let symbols = extract_isx_symbols(input);
|
||||
let library_info = LibraryInfo {
|
||||
name: name.clone(),
|
||||
debug_name: name,
|
||||
path: path.clone(),
|
||||
debug_path: path,
|
||||
debug_id: DebugId::default(),
|
||||
code_id: None,
|
||||
arch: None,
|
||||
symbol_table: symbols.map(|syms| Arc::new(SymbolTable::new(syms))),
|
||||
};
|
||||
let inline_stack_map = InlineStackMap::empty();
|
||||
Self {
|
||||
library_info,
|
||||
inline_stack_map,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn empty(file_path: &Path) -> Self {
|
||||
let (name, path) = name_and_path(file_path);
|
||||
let library_info = LibraryInfo {
|
||||
|
|
@ -135,66 +115,6 @@ fn build_inline_stack_map(file: object::File) -> Result<InlineStackMap> {
|
|||
Ok(frames.build())
|
||||
}
|
||||
|
||||
fn extract_isx_symbols(input: &[u8]) -> Option<Vec<Symbol>> {
|
||||
let mut syms = vec![];
|
||||
let (_, mut buf) = input.split_at_checked(32)?;
|
||||
while !buf.is_empty() {
|
||||
let typ;
|
||||
(typ, buf) = buf.split_first()?;
|
||||
match typ {
|
||||
0x11 => {
|
||||
// Code (Virtual Boy)
|
||||
(_, buf) = buf.split_at_checked(4)?;
|
||||
let len_bytes;
|
||||
(len_bytes, buf) = buf.split_first_chunk()?;
|
||||
let len = u32::from_le_bytes(*len_bytes);
|
||||
(_, buf) = buf.split_at_checked(len as usize)?;
|
||||
}
|
||||
0x13 => {
|
||||
// Range (Virtual Boy)
|
||||
let count_bytes;
|
||||
(count_bytes, buf) = buf.split_first_chunk()?;
|
||||
let count = u16::from_le_bytes(*count_bytes);
|
||||
(_, buf) = buf.split_at_checked(count as usize * 9)?;
|
||||
}
|
||||
0x14 => {
|
||||
// Symbol (Virtual Boy)
|
||||
let count_bytes;
|
||||
(count_bytes, buf) = buf.split_first_chunk()?;
|
||||
let count = u16::from_le_bytes(*count_bytes);
|
||||
for _ in 0..count {
|
||||
let name_len;
|
||||
(name_len, buf) = buf.split_first()?;
|
||||
let name_bytes;
|
||||
(name_bytes, buf) = buf.split_at_checked(*name_len as usize)?;
|
||||
(_, buf) = buf.split_at_checked(2)?;
|
||||
let address_bytes;
|
||||
(address_bytes, buf) = buf.split_first_chunk()?;
|
||||
|
||||
let name_str = String::from_utf8_lossy(name_bytes);
|
||||
let address = u32::from_le_bytes(*address_bytes);
|
||||
syms.push(Symbol {
|
||||
address: address & 0x07ffffff,
|
||||
size: Some(4),
|
||||
name: demangle_any(&name_str),
|
||||
});
|
||||
}
|
||||
}
|
||||
0x20..=0x22 => {
|
||||
// System (undocumented)
|
||||
let length_bytes;
|
||||
(length_bytes, buf) = buf.split_first_chunk()?;
|
||||
let length = u32::from_le_bytes(*length_bytes);
|
||||
(_, buf) = buf.split_at_checked(length as usize)?;
|
||||
}
|
||||
_ => {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(syms)
|
||||
}
|
||||
|
||||
type Reader<'a> = gimli::EndianSlice<'a, gimli::RunTimeEndian>;
|
||||
|
||||
struct ParseContext<'a> {
|
||||
|
|
@ -253,8 +173,8 @@ fn parse_inline(ctx: &mut ParseContext, node: gimli::EntriesTreeNode<Reader>) ->
|
|||
let name = Arc::new(name);
|
||||
let mut ranges = ctx.dorf.die_ranges(ctx.unit, node.entry())?;
|
||||
while let Some(range) = ranges.next()? {
|
||||
let start = range.begin as u32 & 0x07ffffff;
|
||||
let end = range.end as u32 & 0x07ffffff;
|
||||
let start = range.begin as u32;
|
||||
let end = range.end as u32;
|
||||
ctx.frames.add(start, end, name.clone());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -261,7 +261,7 @@ extern "C" fn on_exception(sim: *mut VB, cause: *mut u16) -> c_int {
|
|||
};
|
||||
data.monitor.event = data.monitor.queued_event.take();
|
||||
data.monitor.new_inline_stack = data.monitor.detect_new_inline_stack(pc);
|
||||
data.monitor.queued_event = Some(SimEvent::Interrupt(cause, pc & 0x07ffffff));
|
||||
data.monitor.queued_event = Some(SimEvent::Interrupt(cause, pc));
|
||||
unsafe { vb_set_exception_callback(sim, None) };
|
||||
if data.monitor.event.is_some() || data.monitor.new_inline_stack.is_some() {
|
||||
1
|
||||
|
|
@ -439,9 +439,7 @@ impl EventMonitor {
|
|||
// JAL .+4 is how programs get r31 to a known value for indirect calls
|
||||
// (which we detect later.)
|
||||
// Any other JAL is a function call.
|
||||
return Some(SimEvent::Call(
|
||||
address.wrapping_add_signed(disp) & 0x07ffffff,
|
||||
));
|
||||
return Some(SimEvent::Call(address.wrapping_add_signed(disp)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -455,7 +453,7 @@ impl EventMonitor {
|
|||
if r31 as u32 == address.wrapping_add(2) {
|
||||
// JMP anywhere else, if r31 points to after the JMP, is an indirect call
|
||||
let target = unsafe { vb_get_program_register(sim, jmp_reg as u32) };
|
||||
return Some(SimEvent::Call(target as u32 & 0x07ffffff));
|
||||
return Some(SimEvent::Call(target as u32));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
use std::ffi::c_void;
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
unsafe fn vbu_realloc_shim(ptr: *mut c_void, new_size: usize) -> *mut c_void {
|
||||
if !ptr.is_null() {
|
||||
// not supporting proper realloc because it needs bookkeeping and it's unnecessary
|
||||
return std::ptr::null_mut();
|
||||
}
|
||||
let allocation = vec![0u8; new_size].into_boxed_slice();
|
||||
Box::into_raw(allocation).cast()
|
||||
}
|
||||
|
||||
#[link(name = "vb")]
|
||||
unsafe extern "C" {
|
||||
#[link_name = "vbuFromISX"]
|
||||
fn vbu_from_isx(bytes: *const c_void, length: usize, rom_length: *mut usize) -> *mut c_void;
|
||||
}
|
||||
|
||||
pub fn rom_from_isx(bytes: &[u8]) -> Option<Vec<u8>> {
|
||||
if !bytes.starts_with(b"ISX") {
|
||||
return None;
|
||||
}
|
||||
let mut rom_length = 0;
|
||||
let raw_rom = unsafe { vbu_from_isx(bytes.as_ptr().cast(), bytes.len(), &mut rom_length) };
|
||||
if raw_rom.is_null() {
|
||||
return None;
|
||||
}
|
||||
// SAFETY: the rom was allocated by vbu_realloc_shim, which created it from a Vec<u8>.
|
||||
let rom = unsafe { Vec::from_raw_parts(raw_rom.cast(), rom_length, rom_length) };
|
||||
Some(rom)
|
||||
}
|
||||
15
src/input.rs
15
src/input.rs
|
|
@ -457,10 +457,15 @@ struct PersistedGamepadMapping {
|
|||
default_axes: Vec<(Code, (VBKey, VBKey))>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct Shortcut {
|
||||
pub shortcut: KeyboardShortcut,
|
||||
pub command: Command,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
|
||||
pub enum Command {
|
||||
OpenRom,
|
||||
ReloadRom,
|
||||
Quit,
|
||||
FrameAdvance,
|
||||
FastForward(u32),
|
||||
|
|
@ -471,10 +476,9 @@ pub enum Command {
|
|||
}
|
||||
|
||||
impl Command {
|
||||
pub fn all() -> [Self; 8] {
|
||||
pub fn all() -> [Self; 7] {
|
||||
[
|
||||
Self::OpenRom,
|
||||
Self::ReloadRom,
|
||||
Self::Quit,
|
||||
Self::PauseResume,
|
||||
Self::Reset,
|
||||
|
|
@ -487,7 +491,6 @@ impl Command {
|
|||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::OpenRom => "Open ROM",
|
||||
Self::ReloadRom => "Reload ROM",
|
||||
Self::Quit => "Exit",
|
||||
Self::PauseResume => "Pause/Resume",
|
||||
Self::Reset => "Reset",
|
||||
|
|
@ -519,10 +522,6 @@ impl Default for Shortcuts {
|
|||
Command::OpenRom,
|
||||
KeyboardShortcut::new(Modifiers::COMMAND, Key::O),
|
||||
);
|
||||
shortcuts.set(
|
||||
Command::ReloadRom,
|
||||
KeyboardShortcut::new(Modifiers::COMMAND | Modifiers::SHIFT, Key::F5),
|
||||
);
|
||||
shortcuts.set(
|
||||
Command::Quit,
|
||||
KeyboardShortcut::new(Modifiers::COMMAND, Key::Q),
|
||||
|
|
|
|||
40
src/main.rs
40
src/main.rs
|
|
@ -1,7 +1,7 @@
|
|||
// hide console in release mode
|
||||
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
|
||||
|
||||
use std::{process, time::SystemTime};
|
||||
use std::{path::PathBuf, process, time::SystemTime};
|
||||
|
||||
use anyhow::{Result, bail};
|
||||
use app::Application;
|
||||
|
|
@ -12,15 +12,8 @@ use tracing::error;
|
|||
use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt, util::SubscriberInitExt};
|
||||
use winit::event_loop::{ControlFlow, EventLoop};
|
||||
|
||||
use crate::{
|
||||
config::{CliArgs, SimConfig},
|
||||
emulator::SimId,
|
||||
persistence::Persistence,
|
||||
};
|
||||
|
||||
mod app;
|
||||
mod audio;
|
||||
mod config;
|
||||
mod controller;
|
||||
mod emulator;
|
||||
mod gdbserver;
|
||||
|
|
@ -32,6 +25,18 @@ mod persistence;
|
|||
mod profiler;
|
||||
mod window;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct Args {
|
||||
/// The path to a virtual boy ROM to run.
|
||||
rom: Option<PathBuf>,
|
||||
/// Start a GDB/LLDB debug server on this port.
|
||||
#[arg(short, long)]
|
||||
debug_port: Option<u16>,
|
||||
/// Enable profiling a game
|
||||
#[arg(short, long)]
|
||||
profile: bool,
|
||||
}
|
||||
|
||||
fn init_logger() {
|
||||
let directives = std::env::var("RUST_LOG").unwrap_or("error,lemur=info".into());
|
||||
let filter = EnvFilter::builder().parse_lossy(directives);
|
||||
|
|
@ -93,9 +98,7 @@ fn main() -> Result<()> {
|
|||
#[cfg(windows)]
|
||||
set_process_priority_to_high()?;
|
||||
|
||||
let args = CliArgs::parse();
|
||||
|
||||
let persistence = Persistence::new();
|
||||
let args = Args::parse();
|
||||
|
||||
let (mut builder, client) = EmulatorBuilder::new();
|
||||
if let Some(path) = &args.rom {
|
||||
|
|
@ -110,14 +113,6 @@ fn main() -> Result<()> {
|
|||
if args.profile {
|
||||
builder = builder.start_paused(true)
|
||||
}
|
||||
let p1 = SimConfig::load(&persistence, SimId::Player1);
|
||||
let p2 = SimConfig::load(&persistence, SimId::Player2);
|
||||
|
||||
let watch = args.watch;
|
||||
|
||||
builder = builder
|
||||
.with_audio_on(p1.audio_enabled, p2.audio_enabled)
|
||||
.with_watch_rom(watch, watch);
|
||||
|
||||
ThreadBuilder::default()
|
||||
.name("Emulator".to_owned())
|
||||
|
|
@ -136,6 +131,11 @@ fn main() -> Result<()> {
|
|||
let event_loop = EventLoop::with_user_event().build().unwrap();
|
||||
event_loop.set_control_flow(ControlFlow::Poll);
|
||||
let proxy = event_loop.create_proxy();
|
||||
event_loop.run_app(&mut Application::new(client, proxy, persistence, args))?;
|
||||
event_loop.run_app(&mut Application::new(
|
||||
client,
|
||||
proxy,
|
||||
args.debug_port,
|
||||
args.profile,
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,11 +50,11 @@ impl MemoryClient {
|
|||
}
|
||||
|
||||
fn aligned_memory(start: u32, length: usize) -> BoxBytes {
|
||||
if start.is_multiple_of(4) && length.is_multiple_of(4) {
|
||||
if start % 4 == 0 && length % 4 == 0 {
|
||||
let memory = vec![0u32; length / 4].into_boxed_slice();
|
||||
return bytemuck::box_bytes_of(memory);
|
||||
}
|
||||
if start.is_multiple_of(2) && length.is_multiple_of(2) {
|
||||
if start % 2 == 0 && length % 2 == 0 {
|
||||
let memory = vec![0u16; length / 2].into_boxed_slice();
|
||||
return bytemuck::box_bytes_of(memory);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,11 +60,6 @@ impl ProgramState {
|
|||
let Some(stack) = self.call_stacks.get_mut(code) else {
|
||||
bail!("missing stack {code:04x}");
|
||||
};
|
||||
// just popping the inline frames first
|
||||
while stack
|
||||
.pop_if(|f| matches!(f, StackFrame::Label(_)))
|
||||
.is_some()
|
||||
{}
|
||||
if stack.pop().is_none() {
|
||||
bail!("returned from {code:04x} but stack was empty");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,6 @@
|
|||
use std::sync::Arc;
|
||||
|
||||
pub use about::AboutWindow;
|
||||
use egui::{Context, ViewportBuilder, ViewportId};
|
||||
pub use game::GameWindow;
|
||||
pub use game_screen::DisplayMode;
|
||||
pub use gdb::GdbServerWindow;
|
||||
pub use hotkeys::HotkeysWindow;
|
||||
pub use input::InputWindow;
|
||||
|
|
@ -12,7 +9,7 @@ pub use terminal::TerminalWindow;
|
|||
pub use vip::{
|
||||
BgMapWindow, CharacterDataWindow, FrameBufferWindow, ObjectWindow, RegisterWindow, WorldWindow,
|
||||
};
|
||||
use winit::{event::KeyEvent, window::Window};
|
||||
use winit::event::KeyEvent;
|
||||
|
||||
use crate::emulator::SimId;
|
||||
|
||||
|
|
@ -34,8 +31,9 @@ pub trait AppWindow {
|
|||
}
|
||||
fn initial_viewport(&self) -> ViewportBuilder;
|
||||
fn show(&mut self, ctx: &Context);
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
let _ = args;
|
||||
fn on_init(&mut self, ctx: &Context, render_state: &egui_wgpu::RenderState) {
|
||||
let _ = ctx;
|
||||
let _ = render_state;
|
||||
}
|
||||
fn on_destroy(&mut self) {}
|
||||
fn handle_key_event(&mut self, event: &KeyEvent) -> bool {
|
||||
|
|
@ -47,9 +45,3 @@ pub trait AppWindow {
|
|||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub struct InitArgs<'a> {
|
||||
pub ctx: &'a Context,
|
||||
pub window: &'a Arc<Window>,
|
||||
pub render_state: &'a egui_wgpu::RenderState,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,10 @@
|
|||
use std::{
|
||||
sync::{Arc, mpsc},
|
||||
time::Duration,
|
||||
};
|
||||
use std::{sync::mpsc, time::Duration};
|
||||
|
||||
use crate::{
|
||||
app::UserEvent,
|
||||
config::{COLOR_PRESETS, SimConfig},
|
||||
emulator::{EmulatorClient, EmulatorCommand, EmulatorState, SimId, SimState},
|
||||
input::{Command, ShortcutProvider},
|
||||
persistence::Persistence,
|
||||
window::InitArgs,
|
||||
};
|
||||
use anyhow::Context as _;
|
||||
use egui::{
|
||||
|
|
@ -17,6 +12,7 @@ use egui::{
|
|||
ViewportBuilder, ViewportCommand, ViewportId, Window,
|
||||
};
|
||||
use egui_notify::{Anchor, Toast, Toasts};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use winit::event_loop::EventLoopProxy;
|
||||
|
||||
use super::{
|
||||
|
|
@ -25,18 +21,32 @@ use super::{
|
|||
utils::UiExt as _,
|
||||
};
|
||||
|
||||
const COLOR_PRESETS: [[Color32; 2]; 3] = [
|
||||
[
|
||||
Color32::from_rgb(0xff, 0x00, 0x00),
|
||||
Color32::from_rgb(0x00, 0xc6, 0xf0),
|
||||
],
|
||||
[
|
||||
Color32::from_rgb(0x00, 0xb4, 0x00),
|
||||
Color32::from_rgb(0xc8, 0x00, 0xff),
|
||||
],
|
||||
[
|
||||
Color32::from_rgb(0xb4, 0x9b, 0x00),
|
||||
Color32::from_rgb(0x00, 0x00, 0xff),
|
||||
],
|
||||
];
|
||||
|
||||
pub struct GameWindow {
|
||||
client: EmulatorClient,
|
||||
proxy: EventLoopProxy<UserEvent>,
|
||||
persistence: Persistence,
|
||||
shortcuts: ShortcutProvider,
|
||||
sim_id: SimId,
|
||||
config: SimConfig,
|
||||
config: GameConfig,
|
||||
toasts: Toasts,
|
||||
screen: Option<GameScreen>,
|
||||
messages: Option<mpsc::Receiver<Toast>>,
|
||||
color_picker: Option<ColorPickerState>,
|
||||
window: Option<Arc<winit::window::Window>>,
|
||||
}
|
||||
|
||||
impl GameWindow {
|
||||
|
|
@ -47,7 +57,7 @@ impl GameWindow {
|
|||
shortcuts: ShortcutProvider,
|
||||
sim_id: SimId,
|
||||
) -> Self {
|
||||
let config = SimConfig::load(&persistence, sim_id);
|
||||
let config = load_config(&persistence, sim_id);
|
||||
let toasts = Toasts::new()
|
||||
.with_anchor(Anchor::BottomLeft)
|
||||
.with_margin((10.0, 10.0).into())
|
||||
|
|
@ -63,7 +73,6 @@ impl GameWindow {
|
|||
screen: None,
|
||||
messages: None,
|
||||
color_picker: None,
|
||||
window: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -78,17 +87,13 @@ impl GameWindow {
|
|||
match command {
|
||||
Command::OpenRom => {
|
||||
let rom = rfd::FileDialog::new()
|
||||
.add_filter("Virtual Boy ROMs", &["vb", "vbrom", "elf", "isx"])
|
||||
.add_filter("Virtual Boy ROMs", &["vb", "vbrom"])
|
||||
.pick_file();
|
||||
if let Some(path) = rom {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::LoadGame(self.sim_id, path));
|
||||
}
|
||||
}
|
||||
Command::ReloadRom => {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::ReloadRom(self.sim_id));
|
||||
}
|
||||
Command::Quit => {
|
||||
let _ = self.proxy.send_event(UserEvent::Quit(self.sim_id));
|
||||
}
|
||||
|
|
@ -134,25 +139,13 @@ impl GameWindow {
|
|||
.clicked()
|
||||
{
|
||||
let rom = rfd::FileDialog::new()
|
||||
.add_filter("Virtual Boy ROMs", &["vb", "vbrom", "elf", "isx"])
|
||||
.add_filter("Virtual Boy ROMs", &["vb", "vbrom"])
|
||||
.pick_file();
|
||||
if let Some(path) = rom {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::LoadGame(self.sim_id, path));
|
||||
}
|
||||
}
|
||||
if ui
|
||||
.add(self.button_for(ui.ctx(), "Reload ROM", Command::ReloadRom))
|
||||
.clicked()
|
||||
{
|
||||
self.client
|
||||
.send_command(EmulatorCommand::ReloadRom(self.sim_id));
|
||||
}
|
||||
let watch_rom = self.client.is_rom_watched(self.sim_id);
|
||||
if ui.selectable_button(watch_rom, "Watch ROM").clicked() {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::WatchRom(self.sim_id, !watch_rom));
|
||||
}
|
||||
if ui
|
||||
.add(self.button_for(ui.ctx(), "Quit", Command::Quit))
|
||||
.clicked()
|
||||
|
|
@ -305,13 +298,10 @@ impl GameWindow {
|
|||
self.client
|
||||
.send_command(EmulatorCommand::Screenshot(self.sim_id, tx));
|
||||
let bytes = rx.await.context("Could not take screenshot")?;
|
||||
let mut file_dialog = rfd::FileDialog::new()
|
||||
let file = rfd::FileDialog::new()
|
||||
.add_filter("PNG images", &["png"])
|
||||
.set_file_name("screenshot.png");
|
||||
if let Some(window) = self.window.as_ref() {
|
||||
file_dialog = file_dialog.set_parent(window);
|
||||
}
|
||||
let file = file_dialog.save_file();
|
||||
.set_file_name("screenshot.png")
|
||||
.save_file();
|
||||
let Some(path) = file else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
|
@ -411,15 +401,15 @@ impl GameWindow {
|
|||
});
|
||||
});
|
||||
ui.menu_button("Audio", |ui| {
|
||||
if ui
|
||||
.selectable_button(self.config.audio_enabled, "Enabled")
|
||||
.clicked()
|
||||
{
|
||||
self.update_config(|c| c.audio_enabled = !c.audio_enabled);
|
||||
self.client.send_command(EmulatorCommand::SetAudioEnabled(
|
||||
self.sim_id,
|
||||
self.config.audio_enabled,
|
||||
));
|
||||
let p1_enabled = self.client.is_audio_enabled(SimId::Player1);
|
||||
let p2_enabled = self.client.is_audio_enabled(SimId::Player2);
|
||||
if ui.selectable_button(p1_enabled, "Player 1").clicked() {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::SetAudioEnabled(!p1_enabled, p2_enabled));
|
||||
}
|
||||
if ui.selectable_button(p2_enabled, "Player 2").clicked() {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::SetAudioEnabled(p1_enabled, !p2_enabled));
|
||||
}
|
||||
});
|
||||
ui.menu_button("Input", |ui| {
|
||||
|
|
@ -461,11 +451,13 @@ impl GameWindow {
|
|||
}
|
||||
}
|
||||
|
||||
fn update_config(&mut self, update: impl FnOnce(&mut SimConfig)) {
|
||||
fn update_config(&mut self, update: impl FnOnce(&mut GameConfig)) {
|
||||
let mut new_config = self.config.clone();
|
||||
update(&mut new_config);
|
||||
if self.config != new_config {
|
||||
let _ = new_config.save(&self.persistence, self.sim_id);
|
||||
let _ = self
|
||||
.persistence
|
||||
.save_config(config_filename(self.sim_id), &new_config);
|
||||
}
|
||||
self.config = new_config;
|
||||
}
|
||||
|
|
@ -479,6 +471,24 @@ impl GameWindow {
|
|||
}
|
||||
}
|
||||
|
||||
fn config_filename(sim_id: SimId) -> &'static str {
|
||||
match sim_id {
|
||||
SimId::Player1 => "config_p1",
|
||||
SimId::Player2 => "config_p2",
|
||||
}
|
||||
}
|
||||
|
||||
fn load_config(persistence: &Persistence, sim_id: SimId) -> GameConfig {
|
||||
if let Ok(config) = persistence.load_config(config_filename(sim_id)) {
|
||||
return config;
|
||||
}
|
||||
GameConfig {
|
||||
display_mode: DisplayMode::Anaglyph,
|
||||
colors: COLOR_PRESETS[0],
|
||||
dimensions: DisplayMode::Anaglyph.proportions() + Vec2::new(0.0, 22.0),
|
||||
}
|
||||
}
|
||||
|
||||
impl AppWindow for GameWindow {
|
||||
fn viewport_id(&self) -> ViewportId {
|
||||
match self.sim_id {
|
||||
|
|
@ -535,8 +545,8 @@ impl AppWindow for GameWindow {
|
|||
self.toasts.show(ctx);
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
let (screen, sink) = GameScreen::init(args.render_state);
|
||||
fn on_init(&mut self, _ctx: &Context, render_state: &egui_wgpu::RenderState) {
|
||||
let (screen, sink) = GameScreen::init(render_state);
|
||||
let (message_sink, message_source) = mpsc::channel();
|
||||
self.client.send_command(EmulatorCommand::ConnectToSim(
|
||||
self.sim_id,
|
||||
|
|
@ -545,7 +555,6 @@ impl AppWindow for GameWindow {
|
|||
));
|
||||
self.screen = Some(screen);
|
||||
self.messages = Some(message_source);
|
||||
self.window = Some(args.window.clone());
|
||||
}
|
||||
|
||||
fn on_destroy(&mut self) {
|
||||
|
|
@ -561,3 +570,10 @@ struct ColorPickerState {
|
|||
just_opened: bool,
|
||||
unpause_on_close: bool,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||||
struct GameConfig {
|
||||
display_mode: DisplayMode,
|
||||
colors: [Color32; 2],
|
||||
dimensions: Vec2,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,14 +1,13 @@
|
|||
use std::{fs, sync::Arc, time::Duration};
|
||||
use std::{fs, time::Duration};
|
||||
|
||||
use anyhow::Result;
|
||||
use egui::{Button, CentralPanel, Checkbox, Label, ViewportBuilder, ViewportId};
|
||||
use egui_notify::{Anchor, Toast, Toasts};
|
||||
use winit::window::Window;
|
||||
|
||||
use crate::{
|
||||
emulator::{EmulatorClient, EmulatorCommand, EmulatorState, SimId},
|
||||
profiler::{Profiler, ProfilerStatus},
|
||||
window::{AppWindow, InitArgs},
|
||||
window::AppWindow,
|
||||
};
|
||||
|
||||
pub struct ProfileWindow {
|
||||
|
|
@ -16,7 +15,6 @@ pub struct ProfileWindow {
|
|||
client: EmulatorClient,
|
||||
profiler: Profiler,
|
||||
toasts: Toasts,
|
||||
window: Option<Arc<Window>>,
|
||||
}
|
||||
|
||||
impl ProfileWindow {
|
||||
|
|
@ -29,7 +27,6 @@ impl ProfileWindow {
|
|||
.with_anchor(Anchor::BottomLeft)
|
||||
.with_margin((10.0, 10.0).into())
|
||||
.reverse(true),
|
||||
window: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -62,16 +59,12 @@ impl ProfileWindow {
|
|||
|
||||
fn try_finish_recording(&mut self) -> Result<Option<String>> {
|
||||
let bytes_receiver = self.profiler.finish_recording();
|
||||
let mut file_dialog = rfd::FileDialog::new()
|
||||
let file = rfd::FileDialog::new()
|
||||
.add_filter("Profiler files", &["json"])
|
||||
.set_file_name("profile.json");
|
||||
if let Some(window) = self.window.as_ref() {
|
||||
file_dialog = file_dialog.set_parent(window);
|
||||
}
|
||||
let file = file_dialog.save_file();
|
||||
.set_file_name("profile.json")
|
||||
.save_file();
|
||||
if let Some(path) = file {
|
||||
let bytes = pollster::block_on(bytes_receiver)?;
|
||||
let _ = fs::remove_file(&path);
|
||||
fs::write(&path, bytes)?;
|
||||
Ok(Some(path.display().to_string()))
|
||||
} else {
|
||||
|
|
@ -166,8 +159,4 @@ impl AppWindow for ProfileWindow {
|
|||
});
|
||||
self.toasts.show(ctx);
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
self.window = Some(args.window.clone());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::{
|
|||
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
|
||||
memory::{MemoryClient, MemoryView},
|
||||
window::{
|
||||
AppWindow, InitArgs,
|
||||
AppWindow,
|
||||
utils::{NumberEdit, UiExt},
|
||||
},
|
||||
};
|
||||
|
|
@ -187,8 +187,8 @@ impl AppWindow for BgMapWindow {
|
|||
.with_inner_size((640.0, 480.0))
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
args.ctx.add_texture_loader(self.loader.clone());
|
||||
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
||||
ctx.add_texture_loader(self.loader.clone());
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ use crate::{
|
|||
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
|
||||
memory::{MemoryClient, MemoryView},
|
||||
window::{
|
||||
AppWindow, InitArgs,
|
||||
AppWindow,
|
||||
utils::{NumberEdit, UiExt as _},
|
||||
},
|
||||
};
|
||||
|
|
@ -251,8 +251,8 @@ impl AppWindow for CharacterDataWindow {
|
|||
.with_inner_size((640.0, 480.0))
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
args.ctx.add_texture_loader(self.loader.clone());
|
||||
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
||||
ctx.add_texture_loader(self.loader.clone());
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
|
|
@ -274,6 +274,12 @@ impl AppWindow for CharacterDataWindow {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
|
||||
enum CharDataResource {
|
||||
Character { palette: Palette, index: usize },
|
||||
CharacterData { palette: Palette },
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, PartialEq, Eq)]
|
||||
struct CharDataParams {
|
||||
palette: Palette,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::{
|
|||
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
|
||||
memory::{MemoryClient, MemoryView},
|
||||
window::{
|
||||
AppWindow, InitArgs,
|
||||
AppWindow,
|
||||
utils::{NumberEdit, UiExt as _},
|
||||
},
|
||||
};
|
||||
|
|
@ -153,8 +153,8 @@ impl AppWindow for FrameBufferWindow {
|
|||
.with_inner_size((640.0, 480.0))
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
args.ctx.add_texture_loader(self.loader.clone());
|
||||
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
||||
ctx.add_texture_loader(self.loader.clone());
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::{
|
|||
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
|
||||
memory::{MemoryClient, MemoryView},
|
||||
window::{
|
||||
AppWindow, InitArgs,
|
||||
AppWindow,
|
||||
utils::{NumberEdit, UiExt as _},
|
||||
},
|
||||
};
|
||||
|
|
@ -208,8 +208,8 @@ impl AppWindow for ObjectWindow {
|
|||
.with_inner_size((640.0, 500.0))
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
args.ctx.add_texture_loader(self.loader.clone());
|
||||
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
||||
ctx.add_texture_loader(self.loader.clone());
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ use crate::{
|
|||
images::{ImageBuffer, ImageParams, ImageProcessor, ImageRenderer, ImageTextureLoader},
|
||||
memory::{MemoryClient, MemoryRef, MemoryView},
|
||||
window::{
|
||||
AppWindow, InitArgs,
|
||||
AppWindow,
|
||||
utils::{NumberEdit, UiExt as _},
|
||||
},
|
||||
};
|
||||
|
|
@ -523,8 +523,8 @@ impl AppWindow for WorldWindow {
|
|||
.with_inner_size((640.0, 520.0))
|
||||
}
|
||||
|
||||
fn on_init(&mut self, args: InitArgs) {
|
||||
args.ctx.add_texture_loader(self.loader.clone());
|
||||
fn on_init(&mut self, ctx: &Context, _render_state: &egui_wgpu::RenderState) {
|
||||
ctx.add_texture_loader(self.loader.clone());
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue