Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

debugger!

Layle27ce88be26bf
diff --git a/Cargo.lock b/Cargo.lock
index 6c2f1ca..1694c6c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -628,6 +628,24 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
+[[package]]
+name = "debugger"
+version = "0.1.0"
+dependencies = [
+ "backend-wgpu",
+ "bytemuck",
+ "disasm",
+ "egui",
+ "egui-wgpu",
+ "egui-winit",
+ "egui_material_icons",
+ "gekko",
+ "image 0.1.0",
+ "pollster",
+ "wgpu",
+ "winit",
+]
+
[[package]]
name = "disasm"
version = "0.1.0"
@@ -755,6 +773,15 @@ dependencies = [
"winit",
]
+[[package]]
+name = "egui_material_icons"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff7d3715b5ee29fe75afd19420756b3e0a970149b62712af1b3204a68e2012b"
+dependencies = [
+ "egui",
+]
+
[[package]]
name = "egui_plot"
version = "0.34.1"
diff --git a/Cargo.toml b/Cargo.toml
index 4240ff4..96220f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,7 @@ members = [
"crates/image",
"crates/tinyapp",
"crates/backend-wgpu",
+ "crates/debugger",
]
[patch.crates-io]
diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rs
index 9aa40ad..8e6d705 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -1,5 +1,5 @@
mod helpers;
-mod texture;
+pub mod texture;
use gekko::flipper::gx::draw::{DrawCall, DrawCommands, Primitive, TextureFormat};
use gekko::flipper::gx::regs::{BlendFactor, CompareFunc, MagFilter, MinFilter, WrapMode};
@@ -112,7 +112,10 @@ impl GxRenderer {
) -> Self {
let frame_uniform_size = std::mem::size_of::<FrameUniforms>() as u64;
let draw_uniform_size = std::mem::size_of::<DrawUniforms>() as u64;
- let draw_uniform_stride = align_up(draw_uniform_size, device.limits().min_uniform_buffer_offset_alignment as u64);
+ let draw_uniform_stride = align_up(
+ draw_uniform_size,
+ device.limits().min_uniform_buffer_offset_alignment as u64,
+ );
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("gx_shader"),
diff --git a/crates/backend-wgpu/src/texture.rs b/crates/backend-wgpu/src/texture.rs
index c3674bb..eedd6d7 100644
--- a/crates/backend-wgpu/src/texture.rs
+++ b/crates/backend-wgpu/src/texture.rs
@@ -1,15 +1,10 @@
use gekko::flipper::gx::draw::{TextureDescriptor, TextureFormat};
-pub fn upload_texture(
- device: &wgpu::Device,
- queue: &wgpu::Queue,
- ram: &[u8],
- desc: &TextureDescriptor,
-) -> (wgpu::Texture, wgpu::TextureView) {
+pub fn decode_to_rgba(ram: &[u8], desc: &TextureDescriptor) -> Vec<u8> {
let w = desc.width as usize;
let h = desc.height as usize;
- let mut rgba = vec![0u8; w * h * 4];
+ let mut rgba = vec![0u8; w * h * 4];
match desc.format {
TextureFormat::I4 => decode_i4(ram, desc, &mut rgba, w, h),
TextureFormat::I8 => decode_i8(ram, desc, &mut rgba, w, h),
@@ -19,9 +14,19 @@ pub fn upload_texture(
TextureFormat::RGB5A3 => decode_rgb5a3(ram, desc, &mut rgba, w, h),
TextureFormat::RGBA8 => decode_rgba8(ram, desc, &mut rgba, w, h),
TextureFormat::CMPR => decode_cmpr(ram, desc, &mut rgba, w, h),
- _ => eprintln!("unsupported GX texture format: {:?}", desc.format),
+ _ => panic!("Unsupported texture format: {:?}", desc.format),
}
+ rgba
+}
+
+pub fn upload_texture(
+ device: &wgpu::Device,
+ queue: &wgpu::Queue,
+ ram: &[u8],
+ desc: &TextureDescriptor,
+) -> (wgpu::Texture, wgpu::TextureView) {
+ let rgba = decode_to_rgba(ram, desc);
let tex = device.create_texture(&wgpu::TextureDescriptor {
label: Some("gx_tex"),
size: wgpu::Extent3d {
diff --git a/crates/debugger/Cargo.toml b/crates/debugger/Cargo.toml
new file mode 100644
index 0000000..a713f0e
--- /dev/null
+++ b/crates/debugger/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "debugger"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+gekko = { path = "../gekko" }
+image = { path = "../image" }
+disasm = { path = "../disasm" }
+backend-wgpu = { path = "../backend-wgpu" }
+wgpu = "28.0.0"
+winit = "0.30"
+pollster = "0.4"
+egui = "0.33"
+egui-wgpu = "0.33"
+egui-winit = { version = "0.33", features = ["wayland", "x11"] }
+bytemuck = { version = "1", features = ["derive"] }
+egui_material_icons = "0.5.0"
diff --git a/crates/debugger/src/debugger.rs b/crates/debugger/src/debugger.rs
new file mode 100644
index 0000000..47fc82b
--- /dev/null
+++ b/crates/debugger/src/debugger.rs
@@ -0,0 +1,29 @@
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum EmulatorState {
+ Running,
+ Paused,
+ StepOne,
+ RunUntilVsync,
+}
+
+pub struct DebuggerUi {
+ pub emulator_state: EmulatorState,
+ pub show_cpu: bool,
+ pub show_gx_state: bool,
+ pub show_mmio: bool,
+ pub memory_base: u32,
+ pub memory_addr_input: String,
+}
+
+impl Default for DebuggerUi {
+ fn default() -> Self {
+ DebuggerUi {
+ emulator_state: EmulatorState::Paused,
+ show_cpu: true,
+ show_gx_state: false,
+ show_mmio: false,
+ memory_base: 0x8000_0000,
+ memory_addr_input: "80000000".to_string(),
+ }
+ }
+}
diff --git a/crates/debugger/src/main.rs b/crates/debugger/src/main.rs
new file mode 100644
index 0000000..63093b9
--- /dev/null
+++ b/crates/debugger/src/main.rs
@@ -0,0 +1,92 @@
+use std::env;
+use std::sync::Arc;
+use winit::{
+ application::ApplicationHandler,
+ event::WindowEvent,
+ event_loop::{ActiveEventLoop, EventLoop},
+ window::{Window, WindowId},
+};
+
+use gekko::gekko::Gekko;
+use image::Dol;
+
+use crate::debugger::DebuggerUi;
+use crate::render::RenderState;
+
+mod debugger;
+mod render;
+mod windows;
+
+struct App {
+ emulator: Gekko,
+ ui: DebuggerUi,
+ window: Option<Arc<Window>>,
+ state: Option<RenderState>,
+ present_mode: wgpu::PresentMode,
+}
+
+impl ApplicationHandler for App {
+ fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+ let window = Arc::new(
+ event_loop
+ .create_window(Window::default_attributes().with_title("Gekko"))
+ .unwrap(),
+ );
+
+ let state = RenderState::new(window.clone(), &self.emulator, self.present_mode);
+ window.request_redraw();
+ self.window = Some(window);
+ self.state = Some(state);
+ }
+
+ fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
+ let _ = state.egui_winit.on_window_event(window, &event);
+ }
+
+ match event {
+ WindowEvent::CloseRequested => event_loop.exit(),
+ WindowEvent::Resized(size) => {
+ if let Some(state) = &mut self.state {
+ state.resize(size.width, size.height);
+ }
+ }
+ WindowEvent::RedrawRequested => {
+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
+ state.render(&mut self.emulator, &mut self.ui, window);
+ window.request_redraw();
+ }
+ }
+ _ => {}
+ }
+ }
+}
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 2 {
+ eprintln!("usage: {} <path/to/game.dol> [--immediate] [--idle-skip]", args[0]);
+ std::process::exit(1);
+ }
+
+ let present_mode = args
+ .iter()
+ .any(|a| a == "--immediate")
+ .then_some(wgpu::PresentMode::Immediate)
+ .unwrap_or(wgpu::PresentMode::Fifo);
+ let idle_skip = args.iter().any(|a| a == "--idle-skip");
+
+ let rom_data = std::fs::read(&args[1]).expect("failed to read ROM");
+ let dol = Dol::parse(rom_data);
+ let emulator = Gekko::new(&dol, idle_skip);
+
+ let event_loop = EventLoop::new().unwrap();
+ let mut app = App {
+ emulator,
+ ui: DebuggerUi::default(),
+ window: None,
+ state: None,
+ present_mode,
+ };
+ event_loop.run_app(&mut app).unwrap();
+}
diff --git a/crates/debugger/src/render.rs b/crates/debugger/src/render.rs
new file mode 100644
index 0000000..472ca51
--- /dev/null
+++ b/crates/debugger/src/render.rs
@@ -0,0 +1,453 @@
+use egui::ViewportId;
+use gekko::gekko::Gekko;
+use std::sync::Arc;
+use winit::window::Window;
+
+use crate::debugger::{DebuggerUi, EmulatorState};
+use crate::windows;
+
+const SHADER: &str = include_str!("xfb.wgsl");
+
+pub struct RenderState {
+ surface: wgpu::Surface<'static>,
+ surface_config: wgpu::SurfaceConfiguration,
+ device: wgpu::Device,
+ queue: wgpu::Queue,
+ pipeline: wgpu::RenderPipeline,
+ bind_group_layout: wgpu::BindGroupLayout,
+ texture: wgpu::Texture,
+ bind_group: wgpu::BindGroup,
+ tex_width: u32,
+ tex_height: u32,
+ gx_renderer: backend_wgpu::GxRenderer,
+ pub egui_ctx: egui::Context,
+ pub egui_renderer: egui_wgpu::Renderer,
+ pub egui_winit: egui_winit::State,
+}
+
+impl RenderState {
+ pub fn new(window: Arc<Window>, emulator: &Gekko, present_mode: wgpu::PresentMode) -> Self {
+ let (w, h) = emulator.frame_size();
+ let (w, h) = (w as u32, h as u32);
+
+ let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+ backends: wgpu::Backends::all(),
+ ..Default::default()
+ });
+
+ let surface = instance.create_surface(window.clone()).unwrap();
+
+ let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+ power_preference: wgpu::PowerPreference::default(),
+ compatible_surface: Some(&surface),
+ force_fallback_adapter: false,
+ }))
+ .unwrap();
+
+ let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap();
+
+ let size = window.inner_size();
+ let surface_caps = surface.get_capabilities(&adapter);
+
+ let surface_format = surface_caps
+ .formats
+ .iter()
+ .find(|f| f.is_srgb())
+ .copied()
+ .unwrap_or(surface_caps.formats[0]);
+
+ let surface_config = wgpu::SurfaceConfiguration {
+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+ format: surface_format,
+ width: size.width.max(1),
+ height: size.height.max(1),
+ present_mode,
+ alpha_mode: surface_caps.alpha_modes[0],
+ view_formats: vec![],
+ desired_maximum_frame_latency: 2,
+ };
+ surface.configure(&device, &surface_config);
+
+ let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+ label: None,
+ entries: &[
+ wgpu::BindGroupLayoutEntry {
+ binding: 0,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Texture {
+ multisampled: false,
+ view_dimension: wgpu::TextureViewDimension::D2,
+ sample_type: wgpu::TextureSampleType::Float { filterable: true },
+ },
+ count: None,
+ },
+ wgpu::BindGroupLayoutEntry {
+ binding: 1,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+ count: None,
+ },
+ ],
+ });
+
+ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label: None,
+ source: wgpu::ShaderSource::Wgsl(SHADER.into()),
+ });
+
+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+ label: None,
+ bind_group_layouts: &[&bind_group_layout],
+ immediate_size: 0,
+ });
+
+ let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+ label: None,
+ layout: Some(&pipeline_layout),
+ vertex: wgpu::VertexState {
+ module: &shader,
+ entry_point: Some("vs_main"),
+ buffers: &[],
+ compilation_options: Default::default(),
+ },
+ fragment: Some(wgpu::FragmentState {
+ module: &shader,
+ entry_point: Some("fs_main"),
+ targets: &[Some(wgpu::ColorTargetState {
+ format: surface_format,
+ blend: None,
+ write_mask: wgpu::ColorWrites::ALL,
+ })],
+ compilation_options: Default::default(),
+ }),
+ primitive: wgpu::PrimitiveState::default(),
+ depth_stencil: None,
+ multisample: wgpu::MultisampleState::default(),
+ multiview_mask: None,
+ cache: None,
+ });
+
+ let (texture, bind_group) = create_xfb_texture(&device, &bind_group_layout, w, h);
+ let gx_renderer = backend_wgpu::GxRenderer::new(
+ &device,
+ &queue,
+ surface_format,
+ surface_config.width,
+ surface_config.height,
+ );
+
+ let egui_ctx = egui::Context::default();
+ egui_material_icons::initialize(&egui_ctx);
+ egui_ctx.global_style_mut(|style| {
+ let f = &style.visuals.window_fill;
+ style.visuals.window_fill = egui::Color32::from_rgba_unmultiplied(f.r(), f.g(), f.b(), 240);
+ });
+ let egui_renderer = egui_wgpu::Renderer::new(&device, surface_format, egui_wgpu::RendererOptions::default());
+ let egui_winit = egui_winit::State::new(egui_ctx.clone(), ViewportId::ROOT, window.as_ref(), None, None, None);
+
+ RenderState {
+ surface,
+ surface_config,
+ device,
+ queue,
+ pipeline,
+ bind_group_layout,
+ texture,
+ bind_group,
+ tex_width: w,
+ tex_height: h,
+ gx_renderer,
+ egui_ctx,
+ egui_renderer,
+ egui_winit,
+ }
+ }
+
+ pub fn resize(&mut self, width: u32, height: u32) {
+ if width == 0 || height == 0 {
+ return;
+ }
+ self.surface_config.width = width;
+ self.surface_config.height = height;
+ self.surface.configure(&self.device, &self.surface_config);
+ self.gx_renderer.resize(&self.device, width, height);
+ }
+
+ pub fn render(&mut self, emulator: &mut Gekko, debugger_ui: &mut DebuggerUi, window: &Window) {
+ match debugger_ui.emulator_state {
+ EmulatorState::Running => emulator.run_until_vsync(),
+ EmulatorState::StepOne => {
+ emulator.step();
+ debugger_ui.emulator_state = EmulatorState::Paused;
+ }
+ EmulatorState::RunUntilVsync => {
+ emulator.run_until_vsync();
+ debugger_ui.emulator_state = EmulatorState::Paused;
+ }
+ EmulatorState::Paused => {}
+ }
+
+ let frame = match self.surface.get_current_texture() {
+ Ok(f) => f,
+ Err(e) => {
+ eprintln!("surface error: {e}");
+ return;
+ }
+ };
+ let view = frame.texture.create_view(&Default::default());
+
+ let used_gx = !emulator.gx.draw_commands.commands.is_empty();
+ if used_gx {
+ self.render_gx(emulator, &view);
+ } else {
+ self.render_xfb(emulator, &view);
+ }
+
+ let cpu = &emulator.cpu;
+ let mmio = &emulator.mmio;
+ let gx = &emulator.gx;
+
+ let raw_input = self.egui_winit.take_egui_input(window);
+ let full_output = self.egui_ctx.run_ui(raw_input, |ui| {
+ let ctx = ui.ctx().clone();
+
+ egui::Panel::top("menu_bar").show_inside(ui, |ui| {
+ egui::MenuBar::new().ui(ui, |ui| {
+ ui.menu_button("Emulator", |ui| {
+ let is_paused = debugger_ui.emulator_state == EmulatorState::Paused;
+ let is_running = debugger_ui.emulator_state == EmulatorState::Running;
+
+ use egui_material_icons::icons;
+ if ui
+ .add_enabled(
+ is_paused,
+ egui::Button::new(format!("{} Continue", icons::ICON_PLAY_ARROW)),
+ )
+ .clicked()
+ {
+ debugger_ui.emulator_state = EmulatorState::Running;
+ ui.close();
+ }
+ if ui
+ .add_enabled(is_running, egui::Button::new(format!("{} Pause", icons::ICON_PAUSE)))
+ .clicked()
+ {
+ debugger_ui.emulator_state = EmulatorState::Paused;
+ ui.close();
+ }
+ if ui
+ .add_enabled(is_paused, egui::Button::new(format!("{} Step", icons::ICON_SKIP_NEXT)))
+ .clicked()
+ {
+ debugger_ui.emulator_state = EmulatorState::StepOne;
+ ui.close();
+ }
+ if ui
+ .button(format!("{} Run Until VSync", icons::ICON_FAST_FORWARD))
+ .clicked()
+ {
+ debugger_ui.emulator_state = EmulatorState::RunUntilVsync;
+ ui.close();
+ }
+ });
+
+ ui.menu_button("Windows", |ui| {
+ ui.checkbox(&mut debugger_ui.show_cpu, "CPU");
+ ui.checkbox(&mut debugger_ui.show_gx_state, "GX");
+ ui.checkbox(&mut debugger_ui.show_mmio, "MMIO");
+ });
+ });
+ });
+
+ if debugger_ui.show_cpu {
+ windows::cpu::show_cpu(&ctx, &mut debugger_ui.show_cpu, cpu, mmio);
+ }
+ if debugger_ui.show_gx_state {
+ windows::gx::show_gx(&ctx, &mut debugger_ui.show_gx_state, gx, mmio);
+ }
+ if debugger_ui.show_mmio {
+ windows::mmio::show_mmio(
+ &ctx,
+ &mut debugger_ui.show_mmio,
+ &mut debugger_ui.memory_base,
+ &mut debugger_ui.memory_addr_input,
+ mmio,
+ );
+ }
+ });
+
+ self.egui_winit
+ .handle_platform_output(window, full_output.platform_output);
+
+ let screen_desc = egui_wgpu::ScreenDescriptor {
+ size_in_pixels: [self.surface_config.width, self.surface_config.height],
+ pixels_per_point: window.scale_factor() as f32,
+ };
+ let tris = self
+ .egui_ctx
+ .tessellate(full_output.shapes, screen_desc.pixels_per_point);
+
+ for (id, delta) in full_output.textures_delta.set {
+ self.egui_renderer.update_texture(&self.device, &self.queue, id, &delta);
+ }
+
+ let mut encoder = self
+ .device
+ .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+ self.egui_renderer
+ .update_buffers(&self.device, &self.queue, &mut encoder, &tris, &screen_desc);
+ {
+ let rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: Some("egui"),
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view: &view,
+ resolve_target: None,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Load,
+ store: wgpu::StoreOp::Store,
+ },
+ depth_slice: None,
+ })],
+ depth_stencil_attachment: None,
+ timestamp_writes: None,
+ occlusion_query_set: None,
+ multiview_mask: None,
+ });
+ self.egui_renderer
+ .render(&mut rpass.forget_lifetime(), &tris, &screen_desc);
+ }
+ self.queue.submit([encoder.finish()]);
+
+ for id in full_output.textures_delta.free {
+ self.egui_renderer.free_texture(&id);
+ }
+
+ frame.present();
+
+ // Clear after egui so the GX state window can inspect the draw calls from this frame.
+ if used_gx {
+ emulator.gx.draw_commands.commands.clear();
+ }
+ }
+
+ fn render_gx(&mut self, emulator: &mut Gekko, view: &wgpu::TextureView) {
+ self.gx_renderer.render(
+ &self.device,
+ &self.queue,
+ &emulator.gx.draw_commands,
+ &emulator.mmio.ram,
+ view,
+ self.surface_config.width,
+ self.surface_config.height,
+ );
+ }
+
+ fn render_xfb(&mut self, emulator: &Gekko, view: &wgpu::TextureView) {
+ let pixels = emulator.render_xfb();
+ let (w, h) = emulator.frame_size();
+ let (w, h) = (w as u32, h as u32);
+
+ if (w, h) != (self.tex_width, self.tex_height) {
+ let (texture, bind_group) = create_xfb_texture(&self.device, &self.bind_group_layout, w, h);
+ self.texture = texture;
+ self.bind_group = bind_group;
+ self.tex_width = w;
+ self.tex_height = h;
+ }
+
+ let rgba: Vec<u8> = pixels
+ .iter()
+ .flat_map(|&p| [(p >> 16) as u8, (p >> 8) as u8, p as u8, 0xFF])
+ .collect();
+
+ self.queue.write_texture(
+ wgpu::TexelCopyTextureInfo {
+ texture: &self.texture,
+ mip_level: 0,
+ origin: wgpu::Origin3d::ZERO,
+ aspect: wgpu::TextureAspect::All,
+ },
+ &rgba,
+ wgpu::TexelCopyBufferLayout {
+ offset: 0,
+ bytes_per_row: Some(w * 4),
+ rows_per_image: Some(h),
+ },
+ wgpu::Extent3d {
+ width: w,
+ height: h,
+ depth_or_array_layers: 1,
+ },
+ );
+
+ let mut encoder = self.device.create_command_encoder(&Default::default());
+ {
+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: None,
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view,
+ resolve_target: None,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+ store: wgpu::StoreOp::Store,
+ },
+ depth_slice: None,
+ })],
+ depth_stencil_attachment: None,
+ occlusion_query_set: None,
+ timestamp_writes: None,
+ multiview_mask: None,
+ });
+ rpass.set_pipeline(&self.pipeline);
+ rpass.set_bind_group(0, &self.bind_group, &[]);
+ rpass.draw(0..3, 0..1);
+ }
+ self.queue.submit([encoder.finish()]);
+ }
+}
+
+fn create_xfb_texture(
+ device: &wgpu::Device,
+ layout: &wgpu::BindGroupLayout,
+ w: u32,
+ h: u32,
+) -> (wgpu::Texture, wgpu::BindGroup) {
+ let texture = device.create_texture(&wgpu::TextureDescriptor {
+ label: None,
+ size: wgpu::Extent3d {
+ width: w.max(1),
+ height: h.max(1),
+ depth_or_array_layers: 1,
+ },
+ mip_level_count: 1,
+ sample_count: 1,
+ dimension: wgpu::TextureDimension::D2,
+ format: wgpu::TextureFormat::Rgba8Unorm,
+ usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+ view_formats: &[],
+ });
+
+ let view = texture.create_view(&Default::default());
+ let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+ mag_filter: wgpu::FilterMode::Nearest,
+ min_filter: wgpu::FilterMode::Nearest,
+ ..Default::default()
+ });
+
+ let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: None,
+ layout,
+ entries: &[
+ wgpu::BindGroupEntry {
+ binding: 0,
+ resource: wgpu::BindingResource::TextureView(&view),
+ },
+ wgpu::BindGroupEntry {
+ binding: 1,
+ resource: wgpu::BindingResource::Sampler(&sampler),
+ },
+ ],
+ });
+
+ (texture, bind_group)
+}
diff --git a/crates/debugger/src/windows.rs b/crates/debugger/src/windows.rs
new file mode 100644
index 0000000..9a05805
--- /dev/null
+++ b/crates/debugger/src/windows.rs
@@ -0,0 +1,3 @@
+pub mod cpu;
+pub mod gx;
+pub mod mmio;
diff --git a/crates/debugger/src/windows/cpu.rs b/crates/debugger/src/windows/cpu.rs
new file mode 100644
index 0000000..abf5272
--- /dev/null
+++ b/crates/debugger/src/windows/cpu.rs
@@ -0,0 +1,187 @@
+use egui::{Align, Color32, Context, Grid, RichText, ScrollArea};
+use gekko::cpu::Cpu;
+use gekko::mmio::Mmio;
+
+fn token_color(token: &disasm::tokenizer::AsmToken<'_>) -> Option<Color32> {
+ use disasm::tokenizer::AsmToken;
+ match token {
+ AsmToken::Mnemonic(_) => Some(Color32::from_rgb(100, 180, 255)),
+ AsmToken::Gpr(_) | AsmToken::Fpr(_) | AsmToken::CrField(_) | AsmToken::Spr(_) => {
+ Some(Color32::from_rgb(255, 200, 100))
+ }
+ AsmToken::ImmSigned(_) | AsmToken::ImmUnsigned(_) | AsmToken::ImmHex(_) | AsmToken::Displacement(_) => {
+ Some(Color32::from_rgb(150, 220, 150))
+ }
+ AsmToken::BranchTarget(_) => Some(Color32::from_rgb(255, 150, 150)),
+ AsmToken::Punct(_) | AsmToken::Text(_) => None,
+ }
+}
+
+pub fn show_cpu(ctx: &Context, open: &mut bool, cpu: &Cpu, mmio: &Mmio) {
+ egui::Window::new("CPU")
+ .open(open)
+ .default_size(egui::vec2(1200.0, 800.0))
+ .show(ctx, |ui| {
+ ui.horizontal_top(|ui| {
+ ui.vertical(|ui| {
+ ui.set_min_width(350.0);
+ ui.set_max_width(350.0);
+ Grid::new("special_regs").num_columns(5).striped(true).show(ui, |ui| {
+ ui.label("PC");
+ ui.monospace(format!("{:#010X}", cpu.pc));
+ ui.allocate_space(egui::vec2(16.0, 0.0));
+ ui.label("CTR");
+ ui.monospace(format!("{:#010X}", cpu.spr.ctr));
+ ui.end_row();
+
+ ui.label("LR");
+ ui.monospace(format!("{:#010X}", cpu.spr.lr));
+ ui.allocate_space(egui::vec2(16.0, 0.0));
+ ui.label("MSR");
+ ui.monospace(format!("{:#010X}", cpu.msr.raw()));
+ ui.end_row();
+
+ ui.label("XER");
+ ui.monospace(format!("{:#010X}", cpu.spr.xer.raw()));
+ ui.allocate_space(egui::vec2(16.0, 0.0));
+ ui.label("FPSCR");
+ ui.monospace(format!("{:#010X}", cpu.fpscr));
+ ui.end_row();
+ });
+
+ ui.separator();
+
+ ui.scope(|ui| {
+ Grid::new("cr_fields")
+ .num_columns(9)
+ .spacing([1.0, 1.0])
+ .striped(true)
+ .show(ui, |ui| {
+ ui.label("");
+ for i in 0..8u8 {
+ ui.label(format!("CR{i}"));
+ }
+ ui.end_row();
+
+ for (name, getter) in [
+ ("LT", (|i: u8, c: &Cpu| c.cr.get_field(i).lt()) as fn(u8, &Cpu) -> bool),
+ ("GT", (|i: u8, c: &Cpu| c.cr.get_field(i).gt()) as fn(u8, &Cpu) -> bool),
+ ("EQ", (|i: u8, c: &Cpu| c.cr.get_field(i).eq()) as fn(u8, &Cpu) -> bool),
+ ("SO", (|i: u8, c: &Cpu| c.cr.get_field(i).so()) as fn(u8, &Cpu) -> bool),
+ ] {
+ ui.label(name);
+ for i in 0..8u8 {
+ let mut val = getter(i, cpu);
+ ui.add_enabled(false, egui::Checkbox::without_text(&mut val));
+ }
+ ui.end_row();
+ }
+ });
+ });
+
+ ui.separator();
+
+ let pc = cpu.pc;
+ let start = pc.saturating_sub(16 * 4);
+ let end = pc.saturating_add(16 * 4);
+
+ ScrollArea::vertical()
+ .id_salt("disasm_scroll")
+ .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::VisibleWhenNeeded)
+ .show(ui, |ui| {
+ Grid::new("disasm_grid")
+ .num_columns(4)
+ .min_col_width(0.0)
+ .striped(true)
+ .show(ui, |ui| {
+ let mut addr = start;
+ while addr <= end {
+ let raw = mmio.virt_read_u32(addr);
+ let text = disasm::gekko::GekkoInstruction::decode(&raw.to_be_bytes())
+ .map(|(insn, _)| insn.to_string())
+ .unwrap_or_else(|| format!(".word {:#010X}", raw));
+
+ let is_pc = addr == pc;
+
+ let indicator_resp = if is_pc {
+ Some(
+ ui.label(
+ RichText::new(egui_material_icons::icons::ICON_PLAY_ARROW)
+ .color(Color32::from_rgb(120, 220, 120)),
+ ),
+ )
+ } else {
+ ui.label("");
+ None
+ };
+
+ ui.monospace(format!("{:#010X}", addr));
+
+ ui.label(
+ RichText::new(format!("{:08X}", raw))
+ .monospace()
+ .color(Color32::from_rgb(100, 100, 100)),
+ );
+
+ let tokens = disasm::tokenizer::tokenize(&text);
+ ui.horizontal(|ui| {
+ ui.spacing_mut().item_spacing.x = 0.0;
+ for token in &tokens {
+ let mut rt = RichText::new(token.to_string()).monospace();
+ if let Some(color) = token_color(token) {
+ rt = rt.color(color);
+ }
+ ui.label(rt);
+ }
+ });
+
+ ui.end_row();
+
+ if let Some(resp) = indicator_resp {
+ resp.scroll_to_me(Some(Align::Min));
+ }
+
+ addr = addr.wrapping_add(4);
+ }
+ });
+ });
+ });
+
+ ui.separator();
+
+ ui.vertical(|ui| {
+ ui.label("GPRs");
+ ScrollArea::vertical()
+ .id_salt("gprs_scroll")
+ .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::VisibleWhenNeeded)
+ .show(ui, |ui| {
+ Grid::new("gprs").num_columns(2).striped(true).show(ui, |ui| {
+ for (i, &val) in cpu.gprs.iter().enumerate() {
+ ui.label(format!("r{i:<2}"));
+ ui.monospace(format!("{:#010X}", val));
+ ui.end_row();
+ }
+ });
+ });
+ });
+
+ ui.separator();
+
+ ui.vertical(|ui| {
+ ui.label("FPRs");
+ ScrollArea::vertical()
+ .id_salt("fprs_scroll")
+ .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::VisibleWhenNeeded)
+ .show(ui, |ui| {
+ Grid::new("fprs").num_columns(2).striped(true).show(ui, |ui| {
+ for (i, &val) in cpu.fprs.iter().enumerate() {
+ ui.label(format!("f{i:<2}"));
+ ui.monospace(format!("{:+.6e}", val));
+ ui.end_row();
+ }
+ });
+ });
+ });
+ });
+ });
+}
diff --git a/crates/debugger/src/windows/gx.rs b/crates/debugger/src/windows/gx.rs
new file mode 100644
index 0000000..afe657b
--- /dev/null
+++ b/crates/debugger/src/windows/gx.rs
@@ -0,0 +1,316 @@
+use egui::{Context, Grid, RichText, ScrollArea};
+use egui_material_icons::icons;
+use gekko::flipper::gx::Gx;
+use gekko::flipper::gx::draw::TextureDescriptor;
+use gekko::mmio::Mmio;
+
+fn texture_preview(ui: &mut egui::Ui, tex: &TextureDescriptor, ram: &[u8]) {
+ let rgba = backend_wgpu::texture::decode_to_rgba(ram, tex);
+ let size = [tex.width as usize, tex.height as usize];
+ let image = egui::ColorImage::from_rgba_unmultiplied(size, &rgba);
+ let handle = ui.ctx().load_texture(
+ format!("tex_preview_{:08x}", tex.ram_addr),
+ image,
+ egui::TextureOptions::NEAREST,
+ );
+ let scale = 256.0 / tex.width.max(tex.height) as f32;
+ let display = egui::vec2(tex.width as f32 * scale, tex.height as f32 * scale);
+ ui.image(egui::load::SizedTexture::new(handle.id(), display));
+ ui.separator();
+ ui.label(format!("RAM: 0x{:08X}", tex.ram_addr));
+ ui.label(format!("Wrap S: {:?} T: {:?}", tex.wrap_s, tex.wrap_t));
+ ui.label(format!("Mag: {:?} Min: {:?}", tex.mag_filter, tex.min_filter));
+}
+
+fn mono_header(text: &str) -> RichText {
+ RichText::new(text).monospace().strong()
+}
+
+pub fn show_gx(ctx: &Context, open: &mut bool, gx: &Gx, mmio: &Mmio) {
+ egui::Window::new("GX").open(open).show(ctx, |ui| {
+ let dc = &gx.draw_commands;
+
+ ScrollArea::vertical().show(ui, |ui| {
+ // Summary
+ ui.horizontal(|ui| {
+ ui.strong(format!("{} draw calls", dc.commands.len()));
+ ui.separator();
+ ui.strong(format!("{} TEV stages", dc.num_tev_stages));
+ ui.separator();
+ let n_tex = dc.textures.iter().filter(|t| t.is_some()).count();
+ ui.strong(format!("{n_tex} textures bound"));
+ });
+ ui.separator();
+
+ // Transform
+ ui.collapsing("Transform", |ui| {
+ ui.label("Projection Matrix");
+ Grid::new("proj").num_columns(4).show(ui, |ui| {
+ for row in 0..4 {
+ for col in 0..4 {
+ ui.monospace(format!("{:+9.4}", dc.projection.0[col][row]));
+ }
+ ui.end_row();
+ }
+ });
+ });
+
+ // TEV Stages
+ ui.collapsing(format!("TEV Stages ({})", dc.num_tev_stages), |ui| {
+ for stage in 0..dc.num_tev_stages as usize {
+ let color = dc.tev_color_env[stage];
+ let alpha = dc.tev_alpha_env[stage];
+ let order = dc.tev_orders[stage / 2];
+ let (texmap, texcoord, chan, tex_en) = if stage % 2 == 0 {
+ (
+ order.texmap0(),
+ order.texcoord0(),
+ order.channel0(),
+ order.tex_enable0(),
+ )
+ } else {
+ (
+ order.texmap1(),
+ order.texcoord1(),
+ order.channel1(),
+ order.tex_enable1(),
+ )
+ };
+
+ ui.collapsing(format!("Stage {stage}"), |ui| {
+ Grid::new(format!("tev_{stage}"))
+ .num_columns(2)
+ .striped(true)
+ .show(ui, |ui| {
+ // Texture / raster inputs
+ ui.label("Texture");
+ if tex_en {
+ let primary = if let Some(tex) = dc.textures[texmap as usize] {
+ format!(
+ "tex{texmap} / coord{texcoord} — {:?} {}x{}",
+ tex.format, tex.width, tex.height
+ )
+ } else {
+ format!("tex{texmap} / coord{texcoord} — (unbound)")
+ };
+ let resp = ui.label(primary);
+ if let Some(tex) = dc.textures[texmap as usize] {
+ resp.on_hover_ui(|ui| texture_preview(ui, &tex, &mmio.ram));
+ }
+ } else {
+ ui.monospace("disabled");
+ }
+ ui.end_row();
+
+ ui.label("Raster Channel");
+ ui.monospace(format!("{chan:?}"));
+ ui.end_row();
+
+ ui.label("Color A");
+ ui.monospace(format!("{}", color.a()));
+ ui.end_row();
+ ui.label("Color B");
+ ui.monospace(format!("{}", color.b()));
+ ui.end_row();
+ ui.label("Color C");
+ ui.monospace(format!("{}", color.c()));
+ ui.end_row();
+ ui.label("Color D");
+ ui.monospace(format!("{}", color.d()));
+ ui.end_row();
+ ui.label("Color Destination");
+ ui.monospace(format!("{}", color.dest())).on_hover_text(format!(
+ "bias={:?} scale={:?} sub={} clamp={}",
+ color.bias(),
+ color.scale(),
+ color.sub(),
+ color.clamp(),
+ ));
+ ui.end_row();
+
+ ui.label("Alpha A");
+ ui.monospace(format!("{}", alpha.a()));
+ ui.end_row();
+ ui.label("Alpha B");
+ ui.monospace(format!("{}", alpha.b()));
+ ui.end_row();
+ ui.label("Alpha C");
+ ui.monospace(format!("{}", alpha.c()));
+ ui.end_row();
+ ui.label("Alpha D");
+ ui.monospace(format!("{}", alpha.d()));
+ ui.end_row();
+ ui.label("Alpha Destination");
+ ui.monospace(format!("{}", alpha.dest())).on_hover_text(format!(
+ "bias={:?} scale={:?} sub={} clamp={}",
+ alpha.bias(),
+ alpha.scale(),
+ alpha.sub(),
+ alpha.clamp(),
+ ));
+ ui.end_row();
+ });
+ });
+ }
+ });
+
+ // Textures
+ let bound_count = dc.textures.iter().filter(|t| t.is_some()).count();
+ ui.collapsing(format!("Textures ({bound_count})"), |ui| {
+ if bound_count == 0 {
+ ui.label("none bound");
+ } else {
+ Grid::new("textures").num_columns(2).striped(true).show(ui, |ui| {
+ for (slot, tex_opt) in dc.textures.iter().enumerate() {
+ if let Some(tex) = tex_opt {
+ ui.label(format!("tex{slot}"));
+ ui.monospace(format!(
+ "{:?} {}x{} @ 0x{:08X}",
+ tex.format, tex.width, tex.height, tex.ram_addr
+ ))
+ .on_hover_ui(|ui| texture_preview(ui, tex, &mmio.ram));
+ ui.end_row();
+ }
+ }
+ });
+ }
+ });
+
+ // PE
+ ui.collapsing("Output (PE)", |ui| {
+ Grid::new("output").num_columns(2).striped(true).show(ui, |ui| {
+ let bm = dc.bp_blend_mode;
+
+ ui.label("Blend");
+ if bm.blend_enable() {
+ ui.monospace(format!(
+ "{:?} -> {:?}{}",
+ bm.src_factor(),
+ bm.dst_factor(),
+ if bm.subtract() { " (subtract)" } else { "" },
+ ))
+ .on_hover_text(format!(
+ "Color Write: {} Alpha Write: {} Dither: {}",
+ bm.color_update(),
+ bm.alpha_update(),
+ bm.dither_enable(),
+ ));
+ } else {
+ ui.label("disabled");
+ }
+ ui.end_row();
+
+ if bm.logic_op_enable() {
+ ui.label("Logic Operation");
+ ui.monospace(format!("{:?}", bm.logic_op()));
+ ui.end_row();
+ }
+
+ ui.label("Color Write");
+ ui.monospace(bm.color_update().to_string());
+ ui.end_row();
+
+ ui.label("Alpha Write");
+ ui.monospace(bm.alpha_update().to_string());
+ ui.end_row();
+
+ let zm = dc.bp_zmode;
+ ui.label("Depth Test");
+ if zm.enable() {
+ ui.monospace(format!("{:?} write={}", zm.func(), zm.update_enable(),));
+ } else {
+ ui.label("disabled");
+ }
+ ui.end_row();
+
+ let ac = dc.bp_alpha_compare;
+ ui.label("Alpha Compare");
+ ui.monospace(format!(
+ "{:?}({}) {:?} {:?}({})",
+ ac.comp0(),
+ ac.ref0(),
+ ac.op(),
+ ac.comp1(),
+ ac.ref1(),
+ ));
+ ui.end_row();
+ });
+ });
+
+ // TEV Registers
+ ui.collapsing("TEV Registers", |ui| {
+ Grid::new("tev_regs").num_columns(5).striped(true).show(ui, |ui| {
+ ui.label(mono_header("Reg "));
+ ui.label(mono_header(" R"));
+ ui.label(mono_header(" G"));
+ ui.label(mono_header(" B"));
+ ui.label(mono_header(" A"));
+ ui.end_row();
+
+ for (i, name) in ["Prev", "Reg0", "Reg1", "Reg2"].iter().enumerate() {
+ let lo = dc.tev_color_regs_lo[i];
+ let hi = dc.tev_color_regs_hi[i];
+ ui.monospace(*name);
+ ui.monospace(format!("{:4}", lo.r()));
+ ui.monospace(format!("{:4}", hi.g()));
+ ui.monospace(format!("{:4}", hi.b()));
+ ui.monospace(format!("{:4}", lo.a()));
+ ui.end_row();
+ }
+ });
+ });
+
+ // Draw Calls
+ ui.collapsing(format!("Draw Calls ({})", dc.commands.len()), |ui| {
+ ScrollArea::vertical()
+ .id_salt("draw_calls")
+ .max_height(300.0)
+ .show(ui, |ui| {
+ for (i, call) in dc.commands.iter().enumerate() {
+ let heading = RichText::new(format!(
+ "[{i:>3}] {:?} x {} vertices",
+ call.primitive,
+ call.vertices.len(),
+ ))
+ .monospace();
+
+ ui.collapsing(heading, |ui| {
+ ui.label("Modelview matrix");
+ Grid::new(format!("mv_{i}")).num_columns(4).show(ui, |ui| {
+ for row in 0..4 {
+ for col in 0..4 {
+ ui.monospace(format!("{:+8.3}", call.modelview.0[col][row]));
+ }
+ ui.end_row();
+ }
+ });
+
+ ui.add_space(2.0);
+ let preview = call.vertices.len().min(4);
+ for (vi, v) in call.vertices.iter().take(preview).enumerate() {
+ ui.monospace(format!(
+ "v{vi} position ({:+.3}, {:+.3}, {:+.3})",
+ v.position[0], v.position[1], v.position[2],
+ ));
+ ui.monospace(format!(
+ " color ({:.2}, {:.2}, {:.2}, {:.2})",
+ v.color0[0], v.color0[1], v.color0[2], v.color0[3],
+ ));
+ if let Some(uv) = v.tex0 {
+ ui.monospace(format!(" texcoord ({:+.4}, {:+.4})", uv[0], uv[1],));
+ }
+ }
+ if call.vertices.len() > preview {
+ ui.label(format!(
+ "{} {} more vertices",
+ icons::ICON_MORE_HORIZ,
+ call.vertices.len() - preview,
+ ));
+ }
+ });
+ }
+ });
+ });
+ });
+ });
+}
diff --git a/crates/debugger/src/windows/mmio.rs b/crates/debugger/src/windows/mmio.rs
new file mode 100644
index 0000000..45bb575
--- /dev/null
+++ b/crates/debugger/src/windows/mmio.rs
@@ -0,0 +1,60 @@
+use egui::{Context, Grid, ScrollArea};
+use egui_material_icons::icons;
+use gekko::mmio::Mmio;
+
+pub fn show_mmio(ctx: &Context, open: &mut bool, base: &mut u32, addr_input: &mut String, mmio: &Mmio) {
+ egui::Window::new("Memory").open(open).show(ctx, |ui| {
+ ui.horizontal(|ui| {
+ ui.label("Address:");
+ let resp = ui.add(
+ egui::TextEdit::singleline(addr_input)
+ .desired_width(80.0)
+ .font(egui::TextStyle::Monospace),
+ );
+ let go = ui.button("Go").clicked();
+ if go || (resp.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))) {
+ let s = addr_input.trim().trim_start_matches("0x").trim_start_matches("0X");
+ if let Ok(addr) = u32::from_str_radix(s, 16) {
+ *base = addr & !0xF;
+ }
+ }
+ if ui.button(icons::ICON_CHEVRON_LEFT).clicked() {
+ *base = base.saturating_sub(256);
+ *addr_input = format!("{:08X}", base);
+ }
+ if ui.button(icons::ICON_CHEVRON_RIGHT).clicked() {
+ *base = base.saturating_add(256);
+ *addr_input = format!("{:08X}", base);
+ }
+ });
+
+ ui.separator();
+
+ ScrollArea::vertical().auto_shrink([false; 2]).show(ui, |ui| {
+ Grid::new("mem_grid").num_columns(3).striped(true).show(ui, |ui| {
+ for row in 0u32..16 {
+ let addr = base.wrapping_add(row * 16);
+
+ ui.monospace(format!("{:08X}", addr));
+
+ let mut hex = String::with_capacity(16 * 3 + 1);
+ let mut ascii = String::with_capacity(16);
+ for col in 0u32..16 {
+ if col == 8 {
+ hex.push(' ');
+ }
+ let byte = mmio.virt_read_u8(addr.wrapping_add(col));
+ hex.push_str(&format!("{:02X}", byte));
+ if col < 15 {
+ hex.push(' ');
+ }
+ ascii.push(if byte.is_ascii_graphic() { byte as char } else { '.' });
+ }
+ ui.monospace(&hex);
+ ui.monospace(&ascii);
+ ui.end_row();
+ }
+ });
+ });
+ });
+}
diff --git a/crates/debugger/src/xfb.wgsl b/crates/debugger/src/xfb.wgsl
new file mode 100644
index 0000000..93deb0a
--- /dev/null
+++ b/crates/debugger/src/xfb.wgsl
@@ -0,0 +1,30 @@
+struct VsOut {
+ @builtin(position) pos: vec4<f32>,
+ @location(0) uv: vec2<f32>,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) i: u32) -> VsOut {
+ var pos = array<vec2<f32>, 3>(
+ vec2<f32>(-1.0, 1.0),
+ vec2<f32>( 3.0, 1.0),
+ vec2<f32>(-1.0, -3.0),
+ );
+ var uv = array<vec2<f32>, 3>(
+ vec2<f32>(0.0, 0.0),
+ vec2<f32>(2.0, 0.0),
+ vec2<f32>(0.0, 2.0),
+ );
+ var out: VsOut;
+ out.pos = vec4<f32>(pos[i], 0.0, 1.0);
+ out.uv = uv[i];
+ return out;
+}
+
+@group(0) @binding(0) var xfb_tex: texture_2d<f32>;
+@group(0) @binding(1) var xfb_sam: sampler;
+
+@fragment
+fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
+ return textureSample(xfb_tex, xfb_sam, in.uv);
+}
diff --git a/crates/gekko/src/flipper/gx.rs b/crates/gekko/src/flipper/gx.rs
index 866b857..29b7dc0 100644
--- a/crates/gekko/src/flipper/gx.rs
+++ b/crates/gekko/src/flipper/gx.rs
@@ -647,7 +647,7 @@ impl Gx {
// TEV rasterizer order registers (RAS1_TREF0-7, 0x28-0x2F)
if idx >= BP_RAS1_TREF0 && idx < BP_RAS1_TREF0 + BP_RAS1_TREF_COUNT {
- self.draw_commands.tev_orders[idx - BP_RAS1_TREF0] = val;
+ self.draw_commands.tev_orders[idx - BP_RAS1_TREF0] = regs::TevOrder::from_raw(val);
}
// TEV color registers (0xE0-0xE7): pairs of lo/hi writes
diff --git a/crates/gekko/src/flipper/gx/draw.rs b/crates/gekko/src/flipper/gx/draw.rs
index 0af8b2c..1253c3e 100644
--- a/crates/gekko/src/flipper/gx/draw.rs
+++ b/crates/gekko/src/flipper/gx/draw.rs
@@ -1,6 +1,6 @@
use super::regs::{
- AlphaCompare, BlendMode, MagFilter, MinFilter, TevAlphaEnv, TevColorEnv, TevRegisterH, TevRegisterL, WrapMode,
- ZMode,
+ AlphaCompare, BlendMode, MagFilter, MinFilter, TevAlphaEnv, TevColorEnv, TevOrder, TevRegisterH, TevRegisterL,
+ WrapMode, ZMode,
};
use chapa::BitEnum;
@@ -115,7 +115,7 @@ pub struct DrawCommands {
pub tev_color_regs_hi: [TevRegisterH; 4],
pub tev_const_regs_lo: [TevRegisterL; 4],
pub tev_const_regs_hi: [TevRegisterH; 4],
- pub tev_orders: [u32; 8],
+ pub tev_orders: [TevOrder; 8],
pub num_tev_stages: u8,
// BP state
diff --git a/crates/gekko/src/flipper/gx/regs.rs b/crates/gekko/src/flipper/gx/regs.rs
index 638f611..c799c14 100644
--- a/crates/gekko/src/flipper/gx/regs.rs
+++ b/crates/gekko/src/flipper/gx/regs.rs
@@ -361,6 +361,47 @@ pub enum MinFilter {
LinearMipmapLinear = 6,
}
+#[derive(Debug, PartialEq, Eq, Hash, BitEnum)]
+pub enum RasterChannel {
+ Color0 = 0,
+ Color1 = 1,
+ Alpha0 = 2,
+ Alpha1 = 3,
+ Color0A0 = 4,
+ Color1A1 = 5,
+ ColorZero = 6,
+ Bump = 7,
+}
+
+// BP 0x28-0x2F RAS1_TREF0-7
+#[chapa::bitfield(u32, order = lsb0)]
+#[derive(Debug, Clone, Copy, Default)]
+pub struct TevOrder {
+ #[bits(0..=2)]
+ pub texmap0: u8,
+
+ #[bits(3..=5)]
+ pub texcoord0: u8,
+
+ #[bits(6)]
+ pub tex_enable0: bool,
+
+ #[bits(7..=9)]
+ pub channel0: RasterChannel,
+
+ #[bits(12..=14)]
+ pub texmap1: u8,
+
+ #[bits(15..=17)]
+ pub texcoord1: u8,
+
+ #[bits(18)]
+ pub tex_enable1: bool,
+
+ #[bits(19..=21)]
+ pub channel1: RasterChannel,
+}
+
#[chapa::bitfield(u32, order = lsb0)]
#[derive(Debug, Clone, Copy)]
pub struct TxSetMode0 {
@@ -398,6 +439,29 @@ pub enum TevColorIn {
Zero = 0xF,
}
+impl std::fmt::Display for TevColorIn {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(match self {
+ Self::PrevColor => "Previous Color",
+ Self::PrevAlpha => "Previous Alpha",
+ Self::Reg0Color => "Reg0 Color",
+ Self::Reg0Alpha => "Reg0 Alpha",
+ Self::Reg1Color => "Reg1 Color",
+ Self::Reg1Alpha => "Reg1 Alpha",
+ Self::Reg2Color => "Reg2 Color",
+ Self::Reg2Alpha => "Reg2 Alpha",
+ Self::TexColor => "Texture Color",
+ Self::TexAlpha => "Texture Alpha",
+ Self::RasColor => "Vertex Color",
+ Self::RasAlpha => "Vertex Alpha",
+ Self::One => "1",
+ Self::Half => "0.5",
+ Self::Konst => "Constant",
+ Self::Zero => "0",
+ })
+ }
+}
+
#[derive(Debug, PartialEq, BitEnum)]
pub enum TevBias {
Zero = 0,
@@ -421,6 +485,17 @@ pub enum TevRegId {
TevReg2 = 3,
}
+impl std::fmt::Display for TevRegId {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(match self {
+ Self::TevPrev => "Previous",
+ Self::TevReg0 => "Reg0",
+ Self::TevReg1 => "Reg1",
+ Self::TevReg2 => "Reg2",
+ })
+ }
+}
+
// BP 0xC0+stage*2 TEV
#[chapa::bitfield(u32, order = lsb0)]
@@ -467,6 +542,21 @@ pub enum TevAlphaIn {
Zero = 7,
}
+impl std::fmt::Display for TevAlphaIn {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(match self {
+ Self::PrevAlpha => "Previous Alpha",
+ Self::Reg0Alpha => "Reg0 Alpha",
+ Self::Reg1Alpha => "Reg1 Alpha",
+ Self::Reg2Alpha => "Reg2 Alpha",
+ Self::TexAlpha => "Texture Alpha",
+ Self::RasAlpha => "Vertex Alpha",
+ Self::Konst => "Constant",
+ Self::Zero => "0",
+ })
+ }
+}
+
// BP 0xC1+stage*2 TEV
#[chapa::bitfield(u32, order = lsb0)]
#[derive(Debug, Clone, Copy, Default)]