A GameCube/Wii emulator and debugger written in Rust.
debugger!
Layle27ce88be26bf
diff --git a/Cargo.lock b/Cargo.lockindex 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.tomlindex 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.rsindex 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.rsindex 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.tomlnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.wgslnew file mode 100644index 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.rsindex 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 writesdiff --git a/crates/gekko/src/flipper/gx/draw.rs b/crates/gekko/src/flipper/gx/draw.rsindex 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 statediff --git a/crates/gekko/src/flipper/gx/regs.rs b/crates/gekko/src/flipper/gx/regs.rsindex 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)]