A GameCube/Wii emulator and debugger written in Rust.
wip z freeze implementation & 3d depth view in fifoplayer. seems to work in mario golf and custom z freeze test
Layle0d044bd0d4a0
diff --git a/Cargo.lock b/Cargo.lockindex b2cb5d5..eec2abc 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -533,7 +533,7 @@ dependencies = ["chapa","crossbeam-channel","gecko",- "glam 0.32.1",+ "glam 0.33.7","hotpath","png","renderdoc",@@ -1525,7 +1525,7 @@ dependencies = ["egui","egui-phosphor","gecko",- "glam 0.33.2",+ "glam 0.33.7","image 0.1.0",]@@ -2042,6 +2042,7 @@ dependencies = ["egui-wgpu","egui-winit","gecko",+ "glam 0.33.7","pollster","tracing","tracing-subscriber",@@ -2297,7 +2298,7 @@ dependencies = ["crossbeam-channel","dff","disasm",- "glam 0.32.1",+ "glam 0.33.7","hotpath","hound","image 0.1.0",@@ -2451,19 +2452,13 @@ checksum = "151665d9be52f9bb40fc7966565d39666f2d1e69233571b71b87791c7e0528b3"[[package]]name = "glam"-version = "0.32.1"+version = "0.33.7"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"+checksum = "e762b9b188634fc508d4ec54b62ea3d352c43fd431d18d05d46f559f217f4725"dependencies = ["bytemuck",]-[[package]]-name = "glam"-version = "0.33.2"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "7f22fb22f065b308be0d8724e3706c7fa3fc2a6c7d6899df4cad7860e7a75436"-[[package]]name = "glob"version = "0.3.3"diff --git a/crates/backend-wgpu/Cargo.toml b/crates/backend-wgpu/Cargo.tomlindex 6a88e9f..8e55367 100644--- a/crates/backend-wgpu/Cargo.toml+++ b/crates/backend-wgpu/Cargo.toml@@ -16,7 +16,7 @@ bytemuck = { version = "1.25.0", features = ["derive"] }gecko = { path = "../gecko", default-features = false }chapa = "0.1.2"wesl = "0.3.2"-glam = { version = "0.32.1", features = ["bytemuck"] }+glam = { version = "0.33.7", features = ["bytemuck"] }crossbeam-channel = "0.5.15"tracing = "0.1.44"rustc-hash = "2.1.2"diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex bde7a5f..0f49219 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -60,7 +60,11 @@ fn pack_u32_slice_to_uvec4x4(data: &[u32]) -> [UVec4; 4] {]}-fn build_frame_uniform(draw: &DrawState, alpha_cmp: gecko::flipper::gx::regs::AlphaCompare) -> FrameUniforms {+fn build_frame_uniform(+ draw: &DrawState,+ alpha_cmp: gecko::flipper::gx::regs::AlphaCompare,+ efb_scale: u32,+) -> FrameUniforms {FrameUniforms {tev_color_regs: draw.tev_color_regs.map(Vec4::from),tev_konst_colors: draw.tev_konst_colors.map(Vec4::from),@@ -99,11 +103,14 @@ fn build_frame_uniform(draw: &DrawState, alpha_cmp: gecko::flipper::gx::regs::Alztex_type: draw.ztex_type as u32,ztex_op: draw.ztex_op as u32,_pad2: 0,+ zfreeze_plane: draw.zfreeze.map_or(Vec4::ZERO, |p| {+ Vec4::new(p.dx / efb_scale as f32, p.dy / efb_scale as f32, p.c, 1.0)+ }),}}impl GxRenderer {- fn current_pipeline_key(&self, ztex: bool) -> PipelineKey {+ fn current_pipeline_key(&self, per_pixel_depth: bool) -> PipelineKey {let blend = self.current_blend_mode;let zmode = self.current_zmode;PipelineKey {@@ -119,7 +126,7 @@ impl GxRenderer {color_update: blend.color_update(),alpha_update: blend.alpha_update(),cull_mode: self.current_cull_mode,- ztex,+ per_pixel_depth,}}@@ -135,7 +142,7 @@ impl GxRenderer {/// `previous`, rebasing the indices onto the merged vertex range.fn merge_into_previous(&mut self, previous: usize, draw: &DrawSegment) {let vertex_bias = self.scratch_draws[previous].vertex_count;- let (_, additional_indices) = self::emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);+ let additional_indices = self::emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);let merged = &mut self.scratch_draws[previous];merged.vertex_count += draw.vertex_count;@@ -406,7 +413,7 @@ impl GxRenderer {} else {ShaderSpecializationKey::from_draw(state, self.current_alpha_compare, shader_key)};- let ztex_enabled = state.ztex_op != 0;+ let per_pixel_depth = state.ztex_op != 0 || state.zfreeze.is_some();let active = if self.current_shader_key.is_some() {self.current_active_texture_mask} else {@@ -414,7 +421,7 @@ impl GxRenderer {};let num_indirect_stages = state.num_indirect_stages;let next_frame_uniform = (state_changed || self.last_frame_uniform_index.is_none())- .then(|| build_frame_uniform(state, self.current_alpha_compare));+ .then(|| build_frame_uniform(state, self.current_alpha_compare, self.efb_scale));if !self.shader_cache.contains_key(&shader_key) {#[cfg(feature = "gx-stats")]let shader_started = std::time::Instant::now();@@ -434,7 +441,7 @@ impl GxRenderer {tracing::info!(?shader_key, "compiled specialized shader variant");}- let pipeline_key = self.current_pipeline_key(ztex_enabled);+ let pipeline_key = self.current_pipeline_key(per_pixel_depth);let full_key = FullPipelineKey {shader: shader_key,specialization,@@ -553,7 +560,7 @@ impl GxRenderer {self.merge_into_previous(previous, draw);} else {let first_index = self.scratch_indices.len() as u32;- let (_, index_count) = emit_draw_indices(draw, &mut self.scratch_indices, 0);+ let index_count = self::emit_draw_indices(draw, &mut self.scratch_indices, 0);let start = self.scratch_draws.len() * draw_stride;self.scratch_uniform_bytes.resize(start + draw_stride, 0);@@ -1195,77 +1202,21 @@ fn uniform_slots_equal(bytes: &[u8], stride: usize, size: usize, a: u32, b: u32)}fn draw_emits_triangles(draw: &DrawSegment) -> bool {- use gecko::flipper::gx::draw::Primitive;-- match draw.primitive {- Primitive::Triangles | Primitive::TriangleStrip | Primitive::TriangleFan | Primitive::Quads => {- draw.vertex_count >= 3- }- _ => {- tracing::error!(?draw.primitive, "draw_emits_triangles: skipping unsupported primitive");- false- }+ if !draw.primitive.emits_triangles() {+ tracing::error!(?draw.primitive, "draw_emits_triangles: skipping unsupported primitive");+ return false;}-}--fn emit_draw_indices(draw: &DrawSegment, indices_out: &mut Vec<u32>, vertex_bias: u32) -> (u32, u32) {- use gecko::flipper::gx::draw::Primitive;-- let n = draw.vertex_count;-- match draw.primitive {- Primitive::Triangles => {- let emitted = n - n % 3;- indices_out.extend((0..emitted).map(|i| vertex_bias + i));-- (n, emitted)- }- Primitive::Quads => {- let chunks = n / 4;- for q in 0..chunks {- let base = vertex_bias + q * 4;- indices_out.extend_from_slice(&[base, base + 1, base + 2, base, base + 2, base + 3]);- }-- let mut index_count = chunks * 6;-- if n % 4 == 3 {- let base = vertex_bias + chunks * 4;- indices_out.extend_from_slice(&[base, base + 1, base + 2]);- index_count += 3;- }- (n, index_count)- }- Primitive::TriangleStrip => {- if n < 3 {- return (0, 0);- }+ draw.vertex_count >= 3+}- let tris = n - 2;- for i in 0..tris {- if i & 1 == 0 {- indices_out.extend_from_slice(&[vertex_bias + i, vertex_bias + i + 1, vertex_bias + i + 2]);- } else {- indices_out.extend_from_slice(&[vertex_bias + i + 1, vertex_bias + i, vertex_bias + i + 2]);- }- }- (n, tris * 3)- }- Primitive::TriangleFan => {- if n < 3 {- return (0, 0);- }+fn emit_draw_indices(draw: &DrawSegment, indices_out: &mut Vec<u32>, vertex_bias: u32) -> u32 {+ let count = draw.primitive.triangle_count(draw.vertex_count) * 3;+ indices_out.reserve(count as usize);- let tris = n - 2;- for i in 0..tris {- indices_out.extend_from_slice(&[vertex_bias, vertex_bias + i + 1, vertex_bias + i + 2]);- }- (n, tris * 3)- }- _ => {- tracing::error!(?draw.primitive, "emit_draw_indices: skipping unsupported primitive");- (0, 0)- }+ for tri in draw.primitive.triangles(draw.vertex_count) {+ indices_out.extend(tri.map(|i| vertex_bias + i));}++ count}diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex cc3a3b0..ef6d673 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -190,19 +190,20 @@ pub(crate) struct FrameUniforms {pub material_color0: glam::Vec4,pub material_color1: glam::Vec4,// Z-texture state: bias (24-bit), texel format (0=u8/1=u16/2=u24) and- // op (0=disabled, 1=add, 2=replace). Consumed by the fs_main_ztex entry+ // op (0=disabled, 1=add, 2=replace). Consumed by the fs_main_depth entry// point, which derives the fragment depth from the last texture lookup.pub ztex_bias: u32,pub ztex_type: u32,pub ztex_op: u32,pub _pad2: u32,+ pub zfreeze_plane: glam::Vec4,}pub(crate) const FRAME_UNIFORMS_SIZE: NonZeroU64 = match NonZeroU64::new(std::mem::size_of::<FrameUniforms>() as u64) {Some(v) => v,None => panic!("FrameUniforms must be non-zero sized"),};-const _: () = assert!(std::mem::size_of::<FrameUniforms>() == 1552);+const _: () = assert!(std::mem::size_of::<FrameUniforms>() == 1568);#[repr(C)]#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]diff --git a/crates/backend-wgpu/src/pipeline.rs b/crates/backend-wgpu/src/pipeline.rsindex 943ce69..3fb6b82 100644--- a/crates/backend-wgpu/src/pipeline.rs+++ b/crates/backend-wgpu/src/pipeline.rs@@ -61,9 +61,9 @@ pub(crate) struct PipelineKey {pub color_update: bool,pub alpha_update: bool,pub cull_mode: CullMode,- /// Z-texturing active for this draw: selects the `fs_main_ztex` entry+ /// Z-texturing or Z-freeze active: selects the `fs_main_depth` entry/// point, which writes `frag_depth` (disabling early-Z only where needed).- pub ztex: bool,+ pub per_pixel_depth: bool,}impl PipelineKey {@@ -83,7 +83,7 @@ impl PipelineKey {self.color_update as u8,self.alpha_update as u8,self.cull_mode.raw(),- self.ztex as u8,+ self.per_pixel_depth as u8,]}@@ -101,7 +101,7 @@ impl PipelineKey {color_update: b[9] != 0,alpha_update: b[10] != 0,cull_mode: CullMode::from_raw(b[11]),- ztex: b[12] != 0,+ per_pixel_depth: b[12] != 0,}}}@@ -380,7 +380,11 @@ fn create_pipeline(},fragment: Some(wgpu::FragmentState {module: shader,- entry_point: Some(if key.ztex { "fs_main_ztex" } else { "fs_main" }),+ entry_point: Some(if key.per_pixel_depth {+ "fs_main_depth"+ } else {+ "fs_main"+ }),targets: &[Some(wgpu::ColorTargetState {format: surface_format,blend,diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rsindex 6561c2e..1eaf366 100644--- a/crates/backend-wgpu/src/render.rs+++ b/crates/backend-wgpu/src/render.rs@@ -1068,33 +1068,56 @@ impl GxRenderer {return 0x00FF_FFFF;}+ self.read_efb_depth(device, queue, [x, y, 1, 1])+ .and_then(|v| v.first().copied())+ .unwrap_or(0x00FF_FFFF)+ }++ pub(crate) fn capture_efb_depth(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) -> Option<Vec<u32>> {+ self.read_efb_depth(device, queue, [0, 0, crate::EFB_WIDTH, crate::EFB_HEIGHT])+ }++ fn read_efb_depth(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, rect: [u32; 4]) -> Option<Vec<u32>> {+ let [_, _, width, height] = rect;+self.flush_pending_draws(device, queue);- let (staging, capacity, bytes_per_row) = self.encode_depth_readback(device, queue, [x, y, 1, 1], [1, 1]);+ let (staging, capacity, stride) = self.encode_depth_readback(device, queue, rect, [width, height]);let submission_index = self.submit_pending(queue);- let (done_tx, done_rx) = std::sync::mpsc::channel();- staging- .slice(..bytes_per_row)- .map_async(wgpu::MapMode::Read, move |result| {- let _ = done_tx.send(result);- });- let poll_result = device.poll(wgpu::PollType::Wait {+ let size = stride * height as u64;++ let (tx, rx) = std::sync::mpsc::channel();+ staging.slice(..size).map_async(wgpu::MapMode::Read, move |result| {+ let _ = tx.send(result);+ });++ let poll = device.poll(wgpu::PollType::Wait {submission_index,timeout: Some(std::time::Duration::from_secs(5)),});- let map_result = done_rx.try_recv();- let depth = if poll_result.is_ok() && matches!(map_result, Ok(Ok(()))) {- let mapped = staging.slice(..bytes_per_row).get_mapped_range();- ((mapped[0] as u32) << 16) | ((mapped[1] as u32) << 8) | mapped[2] as u32+ let result = if poll.is_ok() && matches!(rx.try_recv(), Ok(Ok(()))) {+ let mapped = staging.slice(..size).get_mapped_range();++ Some(+ mapped+ .chunks_exact(stride as usize)+ .flat_map(|row| {+ row[..width as usize * 4]+ .chunks_exact(4)+ .map(|p| ((p[0] as u32) << 16) | ((p[1] as u32) << 8) | p[2] as u32)+ })+ .collect(),+ )} else {- tracing::warn!(?poll_result, ?map_result, "EFB depth peek failed");- 0x00FF_FFFF+ tracing::warn!(?poll, "EFB depth snapshot failed");+ None};+staging.unmap();self.return_readback_staging(staging, capacity);- depth+ result}pub(crate) fn ensure_writeback_target(diff --git a/crates/backend-wgpu/src/shader_specialization.rs b/crates/backend-wgpu/src/shader_specialization.rsindex 170cd48..46e1e02 100644--- a/crates/backend-wgpu/src/shader_specialization.rs+++ b/crates/backend-wgpu/src/shader_specialization.rs@@ -16,7 +16,7 @@ const MAIN_WESL: &str = include_str!("shaders/main.wesl");pub(crate) const KEY_BYTES: usize = 6;pub(crate) const SPECIALIZATION_KEY_BYTES: usize = 82 * size_of::<u32>();const CACHE_MAGIC: [u8; 4] = *b"GSKC";-pub(crate) const CACHE_VERSION: u32 = 8;+pub(crate) const CACHE_VERSION: u32 = 9;pub(crate) fn shader_cache_path() -> std::path::PathBuf {gecko::paths::cache("shader_keys.bin")}diff --git a/crates/backend-wgpu/src/shaders/common.wesl b/crates/backend-wgpu/src/shaders/common.weslindex ec90489..3cb4087 100644--- a/crates/backend-wgpu/src/shaders/common.wesl+++ b/crates/backend-wgpu/src/shaders/common.wesl@@ -41,6 +41,7 @@ struct FrameUniforms {ztex_type: u32,ztex_op: u32,_pad2: u32,+ zfreeze_plane: vec4<f32>,};struct DrawUniforms {diff --git a/crates/backend-wgpu/src/shaders/main.wesl b/crates/backend-wgpu/src/shaders/main.weslindex 85457ab..f55b436 100644--- a/crates/backend-wgpu/src/shaders/main.wesl+++ b/crates/backend-wgpu/src/shaders/main.wesl@@ -150,7 +150,7 @@ struct TevState {last_color_dest: u32,last_alpha_dest: u32,// Raw (pre-swap-table) texel of the last TEV stage that sampled a- // texture. Feeds the Z-texture value in fs_main_ztex (hardware: the+ // texture. Feeds the Z-texture value in fs_main_depth (hardware: the// PE's RawTexColor latch).last_raw_tex: vec4<f32>,}@@ -324,28 +324,41 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {return run_tev(in).color;}-struct FsOutZtex {+struct FsOutDepth {@location(0) color: vec4<f32>,@builtin(frag_depth) depth: f32,}@fragment-fn fs_main_ztex(in: VsOut) -> FsOutZtex {+fn fs_main_depth(in: VsOut) -> FsOutDepth {let r = run_tev(in);- let texel = vec4<u32>(round(r.raw_tex * 255.0));- var z: u32 = frame.ztex_bias;- switch shader_state(gx_ztex_type, frame.ztex_type) {- case 0u: { z += texel.a; }- case 1u: { z += (texel.a << 8u) | texel.r; }- default: { z += (texel.r << 16u) | (texel.g << 8u) | texel.b; }+ var depth = in.clip_pos.z;+ var z24 = round((1.0 - depth) * 16777215.0);++ // W enables Z-freeze. XYZ stores the saved plane's A, B, C coeffs.+ // Evaluate z = A*x + B*y + C at this framebuffer pixel, then clamp to Z24.+ // Divide by 2^24 and reverse for host depth (near = 1).+ if frame.zfreeze_plane.w != 0.0 {+ z24 = clamp(dot(frame.zfreeze_plane.xyz, vec3<f32>(in.clip_pos.xy, 1.0)), 0.0, 16777215.0);+ depth = 1.0 - z24 / 16777216.0;}- if shader_state(gx_ztex_op, frame.ztex_op) == 1u {- z += u32(round((1.0 - in.clip_pos.z) * 16777215.0));++ let op = shader_state(gx_ztex_op, frame.ztex_op);+ if op != 0u {+ let texel = vec4<u32>(round(r.raw_tex * 255.0));+ var z: u32 = frame.ztex_bias;+ switch shader_state(gx_ztex_type, frame.ztex_type) {+ case 0u: { z += texel.a; }+ case 1u: { z += (texel.a << 8u) | texel.r; }+ default: { z += (texel.r << 16u) | (texel.g << 8u) | texel.b; }+ }+ if op == 1u { z += u32(round(z24)); }+ z = z & 0x00FFFFFFu;+ depth = 1.0 - f32(z) / 16777215.0;}- z = z & 0x00FFFFFFu;- var out_: FsOutZtex;+ var out_: FsOutDepth;out_.color = r.color;- out_.depth = 1.0 - f32(z) / 16777215.0;+ out_.depth = depth;return out_;}diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex 6702d08..02df5fd 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -565,6 +565,10 @@ impl InlineSink {#[cfg(not(target_arch = "wasm32"))]impl RenderSink for InlineSink {+ fn capture_efb_depth(&mut self) -> Option<Vec<u32>> {+ self.gx.lock().unwrap().capture_efb_depth(&self.device, &self.queue)+ }+fn peek_efb_depth(&mut self, x: u32, y: u32) -> u32 {let mut gx = self.gx.lock().unwrap();let depth = gx.peek_efb_depth(&self.device, &self.queue, x, y);diff --git a/crates/dbglib/Cargo.toml b/crates/dbglib/Cargo.tomlindex 71e75a0..e69bfa1 100644--- a/crates/dbglib/Cargo.toml+++ b/crates/dbglib/Cargo.toml@@ -8,5 +8,5 @@ gecko = { path = "../gecko", default-features = false }disasm = { path = "../disasm" }image = { path = "../image", default-features = false }egui = "0.34.2"-glam = "0.33.2"+glam = "0.33.7"egui-phosphor = "0.12.0"diff --git a/crates/fifoplayer/Cargo.toml b/crates/fifoplayer/Cargo.tomlindex 50b5935..fa2389e 100644--- a/crates/fifoplayer/Cargo.toml+++ b/crates/fifoplayer/Cargo.toml@@ -12,6 +12,7 @@ egui = "0.34.2"egui-phosphor = { version = "0.12.0", features = ["fill"] }egui-wgpu = "0.34.2"egui-winit = { version = "0.34.2", features = ["wayland", "x11"] }+glam = "0.33.7"pollster = "0.4.0"tracing = { version = "0.1.44", features = ["release_max_level_off"] }tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }diff --git a/crates/fifoplayer/src/debug.rs b/crates/fifoplayer/src/debug.rsindex 8b37e25..ceca64e 100644--- a/crates/fifoplayer/src/debug.rs+++ b/crates/fifoplayer/src/debug.rs@@ -1,5 +1,7 @@+mod depth_view;pub mod disasm;pub mod edits;+pub mod geometry;pub mod slice;pub mod ui;@@ -32,6 +34,34 @@ pub struct Breakpoints {pub rows: HashSet<(usize, usize)>,}+#[derive(Debug, PartialEq, Eq)]+pub enum BreakpointSpec {+ Cp(u8),+ Bp(u8),+ Xf(u16),+ Command(usize),+}++pub fn parse_breakpoint(input: &str) -> Result<BreakpointSpec, &'static str> {+ let input = input.to_ascii_lowercase();+ let parts: Vec<_> = input.split_whitespace().collect();++ let [kind, value] = parts.as_slice() else {+ return Err("expected: cmd|cp|bp|xf <hex>");+ };++ let value = usize::from_str_radix(value.strip_prefix("0x").unwrap_or(value), 16)+ .map_err(|_| "invalid hexadecimal value")?;++ match *kind {+ "cmd" => Ok(BreakpointSpec::Command(value)),+ "cp" if value <= 0xff => Ok(BreakpointSpec::Cp(value as u8)),+ "bp" if value <= 0xff => Ok(BreakpointSpec::Bp(value as u8)),+ "xf" if value <= 0xffff => Ok(BreakpointSpec::Xf(value as u16)),+ _ => Err("expected cmd <offset>, cp/bp <00..FF>, or xf <0000..FFFF>"),+ }+}+impl Breakpoints {fn hits(&self, frame: usize, row: usize, cmd: &Command) -> bool {if self.rows.contains(&(frame, row)) {@@ -87,6 +117,8 @@ pub struct DebugSession<const SYSTEM: SystemId> {impl<const SYSTEM: SystemId> DebugSession<SYSTEM> {pub fn new(file: dff::DffFile, path: PathBuf, start: usize, end: usize, mut sink: PlayerSink) -> Self {+ sink.inspection = Some(geometry::GeometryCapture::default());+let mut playback = Playback::<SYSTEM>::new();playback.load_state(&file, &mut sink);@@ -141,6 +173,8 @@ impl<const SYSTEM: SystemId> DebugSession<SYSTEM> {}fn enter_frame(&mut self, idx: usize) {+ self.sink.inspection.as_mut().unwrap().draws.clear();+self.frame_idx = idx;self.row = 0;self.next_update = 0;@@ -183,6 +217,12 @@ impl<const SYSTEM: SystemId> DebugSession<SYSTEM> {self.apply_updates_through(end);if !self.cur.disabled.contains(&off) {+ self.sink.inspection.as_mut().unwrap().location = geometry::DrawLocation {+ frame: self.frame_idx,+ row: self.row,+ offset: off,+ };+let fifo = std::mem::take(&mut self.cur.fifo);self.playback.feed(&fifo[off..end], &mut self.sink);self.cur.fifo = fifo;@@ -318,25 +358,20 @@ impl<const SYSTEM: SystemId> DebugSession<SYSTEM> {if invalidate {self.sink.exec(GxAction::InvalidateCaches);}+self.sink.reset_efb();+ self.sink.inspection = Some(geometry::GeometryCapture::default());self.playback.load_state(&self.file, &mut self.sink);- for f in self.start..frame {- let presented = match self.edits.frame(f) {- None => self.playback.play_frame(&self.file.frames[f], &mut self.sink),- Some(fe) => {- let eff = EffectiveFrame::build(&self.file.frames[f], Some(fe));- let exec = eff.exec_fifo();- self.playback.play_frame_with(&exec, &eff.updates, &mut self.sink)- }- };+ self.enter_frame(self.start);- if presented {- self.presents += 1;+ while self.frame_idx < frame {+ while !self.at_frame_end() {+ self.exec_current();}- }- self.enter_frame(frame);+ self.finish_frame();+ }let row = row.min(self.index.commands.len());for _ in 0..row {diff --git a/crates/fifoplayer/src/debug/depth_view.rs b/crates/fifoplayer/src/debug/depth_view.rsnew file mode 100644index 0000000..22c7ce3--- /dev/null+++ b/crates/fifoplayer/src/debug/depth_view.rs@@ -0,0 +1,717 @@+use super::geometry::{Geometry, GeometryCapture, ProjectedVertex, clip_polygon};+use egui::{Color32, Pos2, Sense, Stroke, Vec2, vec2};+use gecko::flipper::gx::constants::{DEPTH_24_BIT_MAX, EFB_HEIGHT, EFB_WIDTH};+use gecko::flipper::gx::depth::DepthPlane;+use gecko::flipper::gx::regs::CompareFunc;+use glam::{Mat3, Vec3};+use std::collections::{HashMap, HashSet};+use std::sync::Arc;++const OWN: Color32 = Color32::from_rgb(70, 220, 255);+const FROZEN: Color32 = Color32::from_rgb(120, 240, 160);+const REFERENCE: Color32 = Color32::GOLD;+const SCENE: Color32 = Color32::from_rgb(135, 155, 185);++pub struct DepthView {+ yaw: f32,+ pitch: f32,+ zoom: f32,+ pan: Vec2,+ expand_far: bool,+ stretch: f32,+ show_own: bool,+ show_frozen: bool,+ show_plane: bool,+ show_scene: bool,+ writers_only: bool,+ show_textures: bool,+ pub show_test: bool,+ textures: HashMap<(usize, egui::TextureWrapMode), egui::TextureHandle>,+ cached_draws: Vec<Arc<Geometry>>,+ polygons: Vec<Polygon>,+}++struct Polygon {+ draw: usize,+ points: Vec<ProjectedVertex>,+}++impl Default for DepthView {+ fn default() -> Self {+ Self {+ yaw: -0.85,+ pitch: 0.25,+ zoom: 1.0,+ pan: Vec2::ZERO,+ expand_far: true,+ stretch: 1.0,+ show_own: true,+ show_frozen: true,+ show_plane: true,+ show_scene: true,+ writers_only: false,+ show_textures: true,+ show_test: true,+ textures: HashMap::new(),+ cached_draws: Vec::new(),+ polygons: Vec::new(),+ }+ }+}++fn depth_fraction(z: f32, expand_far: bool) -> f32 {+ let z = (z / DEPTH_24_BIT_MAX).clamp(0.0, 1.0);++ if expand_far {+ (65537.0 / (1.0 + (1.0 - z) * 65536.0)).ln() / 65537.0_f32.ln()+ } else {+ z+ }+}++fn on_plane(p: Vec3, plane: DepthPlane) -> Vec3 {+ Vec3::new(p.x, p.y, plane.eval(p.x, p.y))+}++fn depth_passes(func: CompareFunc, incoming: u32, stored: u32) -> bool {+ match func {+ CompareFunc::Never => false,+ CompareFunc::Less => incoming < stored,+ CompareFunc::Equal => incoming == stored,+ CompareFunc::LessEqual => incoming <= stored,+ CompareFunc::Greater => incoming > stored,+ CompareFunc::NotEqual => incoming != stored,+ CompareFunc::GreaterEqual => incoming >= stored,+ CompareFunc::Always => true,+ }+}++fn compare_symbol(func: CompareFunc) -> &'static str {+ match func {+ CompareFunc::Never => "never",+ CompareFunc::Less => "<",+ CompareFunc::Equal => "=",+ CompareFunc::LessEqual => "≤",+ CompareFunc::Greater => ">",+ CompareFunc::NotEqual => "≠",+ CompareFunc::GreaterEqual => "≥",+ CompareFunc::Always => "always",+ }+}++fn probe_point(pointer: Pos2, xy: [Pos2; 3], vertices: [Vec3; 3]) -> Option<Vec3> {+ let matrix = Mat3::from_cols_array_2d(&xy.map(|p| [p.x, p.y, 1.0]));++ if matrix.determinant().abs() < 1e-6 {+ return None;+ }++ let weights = matrix.inverse() * Vec3::new(pointer.x, pointer.y, 1.0);++ if !weights.is_finite() || weights.min_element() < -1e-5 {+ return None;+ }++ let p = Mat3::from_cols(vertices[0], vertices[1], vertices[2]) * weights;+ let (x, y) = (p.x.floor(), p.y.floor());++ if !(0.0..EFB_WIDTH as f32).contains(&x) || !(0.0..EFB_HEIGHT as f32).contains(&y) {+ return None;+ }++ let plane = DepthPlane::from_points(vertices)?;++ Some(self::on_plane(Vec3::new(x + 0.5, y + 0.5, 0.0), plane))+}++fn draw_probe(painter: &egui::Painter, camera: &Camera, draw: &Geometry, original: Vec3) -> String {+ let incoming = if draw.frozen {+ let Some(reference) = &draw.reference else {+ return "Reference plane unavailable".into();+ };++ let incoming = self::on_plane(original, reference.plane);++ let original_xy = camera.project(original).0;+ let incoming_xy = camera.project(incoming).0;++ painter.extend(egui::Shape::dashed_line(+ &[original_xy, incoming_xy],+ Stroke::new(1.5, OWN),+ 5.0,+ 4.0,+ ));+ painter.circle_stroke(original_xy, 4.0, Stroke::new(1.5, OWN));++ incoming+ } else {+ original+ };++ let incoming_z = incoming.z.clamp(0.0, DEPTH_24_BIT_MAX) as u32;+ let incoming_xy = camera.project(incoming).0;++ let Some(depth) = draw.depth_before.get().and_then(Option::as_ref) else {+ painter.circle_stroke(incoming_xy, 4.0, Stroke::new(1.5, Color32::GRAY));+ return "Depth snapshot unavailable".into();+ };++ let (x, y) = (original.x as usize, original.y as usize);++ let Some(&stored_z) = depth.get(y * EFB_WIDTH as usize + x) else {+ return "Outside depth snapshot".into();+ };++ let func = draw.zmode.func();++ let (result, color, status) = if !draw.zmode.enable() {+ ("TEST OFF", Color32::GRAY, "Depth test off".to_string())+ } else if draw.z_texture {+ (+ "Z-TEXTURE",+ Color32::GRAY,+ "Z-texture: comparison unavailable".to_string(),+ )+ } else {+ let (result, color) = if self::depth_passes(func, incoming_z, stored_z) {+ ("PASS", Color32::LIGHT_GREEN)+ } else {+ ("FAIL", Color32::LIGHT_RED)+ };++ let status = match func {+ CompareFunc::Never | CompareFunc::Always => format!("{result} ({})", self::compare_symbol(func)),+ _ => format!(+ "{result} (incoming {incoming_z} {} stored {stored_z})",+ self::compare_symbol(func)+ ),+ };++ (result, color, status)+ };++ let stored_xy = camera.project(Vec3::new(original.x, original.y, stored_z as f32)).0;++ painter.line_segment([incoming_xy, stored_xy], Stroke::new(2.5, Color32::BLACK));+ painter.line_segment([incoming_xy, stored_xy], Stroke::new(1.5, color));+ painter.circle_filled(incoming_xy, 4.0, color);+ painter.circle_stroke(stored_xy, 5.0, Stroke::new(2.0, color));++ painter.text(+ incoming_xy + vec2(10.0, -10.0),+ egui::Align2::LEFT_BOTTOM,+ result,+ egui::FontId::monospace(12.0),+ color,+ );+ painter.text(+ stored_xy + vec2(10.0, 10.0),+ egui::Align2::LEFT_TOP,+ "Stored",+ egui::FontId::monospace(12.0),+ color,+ );++ status+}++fn surface(+ points: &[Pos2],+ fill: Color32,+ stroke: Stroke,+ texture: Option<(egui::TextureId, &[ProjectedVertex])>,+) -> Vec<egui::Shape> {+ let mut shapes = Vec::with_capacity(points.len() + 1);++ if fill != Color32::TRANSPARENT {+ let mut mesh = egui::Mesh::default();++ for &point in points {+ mesh.colored_vertex(point, fill);+ }++ for i in 1..points.len().saturating_sub(1) {+ mesh.add_triangle(0, i as u32, (i + 1) as u32);+ }++ if let Some((id, vertices)) = texture {+ mesh.texture_id = id;++ for (vertex, source) in mesh.vertices.iter_mut().zip(vertices) {+ vertex.uv = source.uv();+ }+ }++ shapes.push(egui::Shape::mesh(mesh));+ }++ for i in 0..points.len() {+ let edge = [points[i], points[(i + 1) % points.len()]];+ shapes.push(egui::Shape::line_segment(edge, stroke));+ }++ shapes+}++fn clip_efb(polygon: Vec<ProjectedVertex>) -> Vec<ProjectedVertex> {+ let bounds = [+ (0, 0.0, 1.0),+ (0, EFB_WIDTH as f32, -1.0),+ (1, 0.0, 1.0),+ (1, EFB_HEIGHT as f32, -1.0),+ ];++ clip_polygon(+ polygon,+ bounds,+ |p, (axis, boundary, sign)| (p.screen[axis] - boundary) * sign,+ ProjectedVertex::lerp,+ )+}++fn status_label(painter: &egui::Painter, position: Pos2, galley: Arc<egui::Galley>, color: Color32) {+ let backdrop = egui::Rect::from_min_size(position, galley.size()).expand(3.0);++ painter.rect_filled(backdrop, 2.0, Color32::from_black_alpha(200));+ painter.galley(position, galley, color);+}++struct Camera {+ center: Pos2,+ scale: f32,+ rotation: Mat3,+ stretch: f32,+ expand_far: bool,+}++impl Camera {+ fn new(view: &DepthView, rect: egui::Rect) -> Self {+ Self {+ center: rect.center() + view.pan,+ scale: rect.width().min(rect.height()) * 0.65 * view.zoom,+ rotation: Mat3::from_rotation_x(view.pitch) * Mat3::from_rotation_y(view.yaw),+ stretch: view.stretch,+ expand_far: view.expand_far,+ }+ }++ fn project(&self, p: Vec3) -> (Pos2, f32) {+ let x = p.x / EFB_WIDTH as f32 - 0.5;+ let y = (p.y - EFB_HEIGHT as f32 * 0.5) / EFB_WIDTH as f32;+ let z = (self::depth_fraction(p.z, self.expand_far) - 0.5) * self.stretch;++ let p = self.rotation * Vec3::new(x, y, z);++ (self.center + vec2(p.x, p.y) * self.scale, p.z)+ }+}++impl DepthView {+ fn scene_is_current(&self, capture: &GeometryCapture) -> bool {+ let total: usize = capture.draws.values().map(Vec::len).sum();++ if total != self.cached_draws.len() {+ return false;+ }++ self.cached_draws.iter().all(|draw| {+ capture+ .draws+ .get(&draw.location.offset)+ .and_then(|draws| draws.get(draw.subdraw))+ .is_some_and(|current| Arc::ptr_eq(current, draw))+ })+ }++ fn update_scene(&mut self, capture: &GeometryCapture, ctx: &egui::Context) {+ if self.scene_is_current(capture) {+ return;+ }++ let mut draws: Vec<_> = capture.draws.values().flatten().cloned().collect();+ draws.sort_by_key(|d| (d.location.row, d.subdraw));++ let mut used = HashSet::new();++ for draw in &draws {+ let Some(texture) = &draw.texture else {+ continue;+ };++ let key = (Arc::as_ptr(texture) as usize, draw.texture_wrap);+ used.insert(key);++ self.textures.entry(key).or_insert_with(|| {+ let options = egui::TextureOptions {+ wrap_mode: draw.texture_wrap,+ ..egui::TextureOptions::LINEAR+ };++ ctx.load_texture("FIFO draw texture", texture.clone(), options)+ });+ }++ self.textures.retain(|key, _| used.contains(key));++ self.polygons.clear();++ for (index, draw) in draws.iter().enumerate() {+ for &triangle in &draw.triangles {+ let points = self::clip_efb(draw.projected_vertices(triangle));++ if points.len() >= 3 && points.iter().all(|p| p.screen.is_finite()) {+ self.polygons.push(Polygon { draw: index, points });+ }+ }+ }++ self.cached_draws = draws;+ }++ fn toolbar(&mut self, ui: &mut egui::Ui, selected: Option<&Arc<Geometry>>) {+ ui.horizontal_wrapped(|ui| {+ for (label, yaw, pitch) in [+ ("Front", 0.0, 0.0),+ ("Side", -std::f32::consts::FRAC_PI_2, 0.0),+ ("Reset", -0.85, 0.25),+ ] {+ if ui.button(label).clicked() {+ self.yaw = yaw;+ self.pitch = pitch;+ self.pan = Vec2::ZERO;+ self.zoom = 1.0;+ }+ }++ ui.separator();++ ui.checkbox(&mut self.show_textures, "Textures");+ ui.checkbox(&mut self.show_own, egui::RichText::new("Original").color(OWN));++ ui.add_enabled_ui(selected.is_some_and(|d| d.frozen), |ui| {+ ui.checkbox(&mut self.show_frozen, egui::RichText::new("Frozen").color(FROZEN));+ });++ ui.checkbox(&mut self.show_plane, egui::RichText::new("Plane").color(REFERENCE));++ ui.checkbox(&mut self.show_test, "Depth test");++ ui.menu_button("Options", |ui| {+ ui.checkbox(&mut self.show_scene, "Scene geometry");+ ui.checkbox(&mut self.writers_only, "Depth writers only");++ ui.separator();++ ui.checkbox(&mut self.expand_far, "Log depth");+ ui.add(egui::Slider::new(&mut self.stretch, 0.2..=4.0).text("Z scale"));+ });+ });+ }++ fn handle_input(&mut self, ui: &egui::Ui, response: &egui::Response) {+ if response.dragged() {+ let delta = ui.input(|i| i.pointer.delta());++ if response.dragged_by(egui::PointerButton::Secondary) || ui.input(|i| i.modifiers.shift) {+ self.pan += delta;+ } else if response.dragged_by(egui::PointerButton::Primary) {+ self.yaw += delta.x * 0.008;+ self.pitch = (self.pitch - delta.y * 0.008).clamp(-1.5, 1.5);+ }+ }++ if response.hovered() {+ let scroll = ui.input(|i| i.smooth_scroll_delta.y);+ self.zoom = (self.zoom * (scroll * 0.002).exp()).clamp(0.1, 20.0);+ }+ }++ fn draw_bounds(painter: &egui::Painter, camera: &Camera) {+ let (w, h) = (EFB_WIDTH as f32, EFB_HEIGHT as f32);+ let corners = [+ Vec3::ZERO,+ Vec3::new(w, 0.0, 0.0),+ Vec3::new(w, h, 0.0),+ Vec3::new(0.0, h, 0.0),+ ];++ for z in [0.0, DEPTH_24_BIT_MAX] {+ let points = corners.map(|p| camera.project(p.with_z(z)).0);++ let stroke = Stroke::new(1.0, Color32::from_gray(65));+ painter.extend(self::surface(&points, Color32::TRANSPARENT, stroke, None));+ }++ for p in corners {+ let near = camera.project(p).0;+ let far = camera.project(p.with_z(DEPTH_24_BIT_MAX)).0;++ painter.line_segment([near, far], Stroke::new(1.0, Color32::from_gray(50)));+ }++ for (z, label) in [(0.0, "Z = 0 (near)"), (DEPTH_24_BIT_MAX, "Z = 1 (far)")] {+ let p = camera.project(Vec3::new(0.0, h, z)).0;++ painter.text(+ p + vec2(0.0, 10.0),+ egui::Align2::LEFT_TOP,+ label,+ egui::FontId::monospace(12.0),+ Color32::LIGHT_GRAY,+ );+ }+ }++ fn draw_reference(painter: &egui::Painter, camera: &Camera, draw: &Arc<Geometry>) {+ let reference = match (&draw.reference, draw.last_plane) {+ (Some(r), _) => (&*r.draw, r.triangle, r.plane),+ (None, Some((triangle, plane))) if !draw.frozen => (&**draw, triangle, plane),+ _ => return,+ };++ let (source, triangle, plane) = reference;+ let (w, h) = (EFB_WIDTH as f32, EFB_HEIGHT as f32);+ let grid_stroke = Stroke::new(0.8, REFERENCE.gamma_multiply(0.35));++ for i in 0..=8 {+ let x = w * i as f32 / 8.0;+ let y = h * i as f32 / 8.0;++ for segment in [+ [Vec3::new(x, 0.0, 0.0), Vec3::new(x, h, 0.0)],+ [Vec3::new(0.0, y, 0.0), Vec3::new(w, y, 0.0)],+ ] {+ let line = segment.map(|p| camera.project(self::on_plane(p, plane)).0);+ painter.line_segment(line, grid_stroke);+ }+ }++ let xy: Vec<_> = source+ .projected_vertices(triangle)+ .iter()+ .map(|p| camera.project(p.screen).0)+ .collect();++ if xy.is_empty() {+ return;+ }++ painter.extend(self::surface(+ &xy,+ Color32::TRANSPARENT,+ Stroke::new(2.0, REFERENCE),+ None,+ ));++ let center = (xy.iter().fold(Vec2::ZERO, |sum, p| sum + p.to_vec2()) / xy.len() as f32).to_pos2();+ let label = center + vec2(20.0, 26.0);++ painter.circle_stroke(center, 6.0, Stroke::new(1.5, REFERENCE));+ painter.line_segment([center, label], Stroke::new(1.0, REFERENCE));+ painter.text(+ label,+ egui::Align2::LEFT_TOP,+ format!("Reference {:06X}", source.location.offset),+ egui::FontId::monospace(12.0),+ REFERENCE,+ );+ }++ fn draw_bound_labels(painter: &egui::Painter, rect: egui::Rect, selected_bounds: [egui::Rect; 2]) {+ let area = rect.shrink(6.0);++ for (bounds, text, color) in [+ (selected_bounds[0], "Original depth", OWN),+ (selected_bounds[1], "Frozen depth", FROZEN),+ ] {+ if !bounds.is_finite() {+ continue;+ }++ let label = painter.layout_no_wrap(text.into(), egui::FontId::monospace(12.0), color);+ let size = label.size();++ let x = bounds.center().x - size.x * 0.5;+ let y = bounds.top() - size.y - 8.0;++ let position = egui::pos2(+ x.clamp(area.left(), (area.right() - size.x).max(area.left())),+ y.clamp(area.top(), (area.bottom() - size.y).max(area.top())),+ );++ self::status_label(painter, position, label, color);+ }+ }++ pub fn show(&mut self, ui: &mut egui::Ui, capture: &GeometryCapture, selected: Option<&Arc<Geometry>>) {+ self.update_scene(capture, ui.ctx());+ self.toolbar(ui, selected);++ let padding = egui::Frame::central_panel(ui.style()).inner_margin.top as f32;+ ui.add_space((padding - ui.spacing().item_spacing.y).max(0.0));++ let size = ui.available_size().max(vec2(1.0, 1.0));+ let (rect, response) = ui.allocate_exact_size(size, Sense::click_and_drag());+ self.handle_input(ui, &response);++ let painter = ui.painter().with_clip_rect(rect);+ painter.rect_filled(rect, 4.0, Color32::from_rgb(16, 20, 26));++ let camera = Camera::new(self, rect);++ Self::draw_bounds(&painter, &camera);++ let mut surfaces = Vec::new();+ let mut selected_bounds = [egui::Rect::NOTHING; 2];+ let mut hover = None;+ let mut probe: Option<(Vec3, f32)> = None;+ let pointer = response.hover_pos();+ let mut nearest = 6.0_f32;++ for polygon in &self.polygons {+ let draw = &self.cached_draws[polygon.draw];+ let is_selected = selected.is_some_and(|s| Arc::ptr_eq(s, draw));++ let variants: &[(bool, Color32)] = if is_selected {+ &[(false, OWN), (true, FROZEN)]+ } else {+ &[(draw.frozen, SCENE)]+ };++ for &(frozen, color) in variants {+ let hidden = if is_selected {+ (!frozen && !self.show_own) || (frozen && (!draw.frozen || !self.show_frozen))+ } else {+ !self.show_scene || (self.writers_only && !(draw.zmode.enable() && draw.zmode.update_enable()))+ };++ if hidden {+ continue;+ }++ let plane = match (frozen, &draw.reference) {+ (false, _) => None,+ (true, Some(reference)) => Some(reference.plane),+ (true, None) => continue,+ };++ let place = |p: Vec3| plane.map_or(p, |plane| self::on_plane(p, plane));++ let points: Vec<_> = polygon.points.iter().map(|p| place(p.screen)).collect();++ let mut depth = 0.0;+ let xy: Vec<_> = points+ .iter()+ .map(|&p| {+ let (xy, z) = camera.project(p);+ depth += z;+ xy+ })+ .collect();+ let depth = depth / xy.len() as f32;++ if is_selected {+ for &p in &xy {+ selected_bounds[frozen as usize].extend_with(p);+ }+ }++ let texture = draw+ .texture+ .as_ref()+ .filter(|_| self.show_textures)+ .and_then(|t| self.textures.get(&(Arc::as_ptr(t) as usize, draw.texture_wrap)))+ .filter(|_| polygon.points.iter().all(|p| p.uv().is_finite()));++ let (width, fade, opacity, tex_alpha) = if is_selected {+ (2.0, 1.0, 45, 190)+ } else if texture.is_some() {+ (0.6, 0.12, 6, 150)+ } else {+ (0.6, 0.35, 6, 150)+ };++ let stroke = Stroke::new(width, color.gamma_multiply(fade));++ let fill = if texture.is_some() {+ Color32::from_white_alpha(tex_alpha)+ } else {+ Color32::from_rgba_unmultiplied(color.r(), color.g(), color.b(), opacity)+ };++ let shapes = self::surface(&xy, fill, stroke, texture.map(|t| (t.id(), polygon.points.as_slice())));+ surfaces.push((depth, shapes));++ let Some(pointer) = pointer else {+ continue;+ };++ if self.show_test && is_selected && !response.dragged() {+ for i in 1..xy.len() - 1 {+ let indices = [0, i, i + 1];++ let Some(p) = self::probe_point(+ pointer,+ indices.map(|j| xy[j]),+ indices.map(|j| polygon.points[j].screen),+ ) else {+ continue;+ };++ let z = camera.project(place(p)).1;++ if probe.is_none_or(|(_, nearest)| z < nearest) {+ probe = Some((p, z));+ }+ }+ }++ for i in 0..xy.len() {+ let j = (i + 1) % xy.len();+ let segment = xy[j] - xy[i];+ let t = ((pointer - xy[i]).dot(segment) / segment.length_sq().max(1e-12)).clamp(0.0, 1.0);++ let distance = pointer.distance(xy[i] + segment * t);++ if distance < nearest {+ nearest = distance;+ hover = Some((draw, frozen, points[i].lerp(points[j], t)));+ }+ }+ }+ }++ surfaces.sort_by(|a, b| b.0.total_cmp(&a.0));+ painter.extend(surfaces.into_iter().flat_map(|(_, shapes)| shapes));++ if self.show_plane+ && let Some(draw) = selected+ {+ Self::draw_reference(&painter, &camera, draw);+ }++ Self::draw_bound_labels(&painter, rect, selected_bounds);++ let status = if let Some((point, _)) = probe+ && let Some(draw) = selected+ {+ self::draw_probe(&painter, &camera, draw, point)+ } else if let Some((draw, frozen, p)) = hover {+ format!(+ "{:06X} · {} · depth {:.0}",+ draw.location.offset,+ if frozen { "frozen" } else { "original" },+ p.z,+ )+ } else {+ String::new()+ };++ if !status.is_empty() {+ let label = painter.layout_no_wrap(status, egui::FontId::monospace(12.0), Color32::LIGHT_GRAY);+ let position = rect.left_bottom() + vec2(8.0, -8.0 - label.size().y);++ self::status_label(&painter, position, label, Color32::LIGHT_GRAY);+ }+ }+}diff --git a/crates/fifoplayer/src/debug/geometry.rs b/crates/fifoplayer/src/debug/geometry.rsnew file mode 100644index 0000000..28984af--- /dev/null+++ b/crates/fifoplayer/src/debug/geometry.rs@@ -0,0 +1,243 @@+use gecko::flipper::gx::GraphicsProcessor;+use gecko::flipper::gx::constants::*;+use gecko::flipper::gx::depth::{self, DepthPlane, ViewportTransform};+use gecko::flipper::gx::draw::Primitive;+use gecko::flipper::gx::regs::{GenMode, WrapMode, ZMode};+use gecko::host::{DrawVertex, GxAction, TextureKey};+use glam::{Vec3, Vec4};+use std::collections::HashMap;+use std::sync::{Arc, OnceLock};++#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub struct DrawLocation {+ pub frame: usize,+ pub row: usize,+ pub offset: usize,+}++#[derive(Clone, Debug)]+pub struct Vertex {+ pub clip: Vec4,+ pub stq: Vec3,+}++#[derive(Clone, Copy)]+pub struct ProjectedVertex {+ pub screen: Vec3,+ pub stq: Vec3,+}++impl ProjectedVertex {+ pub fn lerp(self, other: Self, t: f32) -> Self {+ Self {+ screen: self.screen.lerp(other.screen, t),+ stq: self.stq.lerp(other.stq, t),+ }+ }++ pub fn uv(self) -> egui::Pos2 {+ let uv = self.stq.truncate() / self.stq.z;++ egui::pos2(uv.x, uv.y)+ }+}++#[derive(Clone, Debug)]+pub struct Reference {+ pub draw: Arc<Geometry>,+ pub triangle: [usize; 3],+ pub plane: DepthPlane,+}++#[derive(Debug)]+pub struct Geometry {+ pub location: DrawLocation,+ pub subdraw: usize,+ pub vertices: Vec<Vertex>,+ pub triangles: Vec<[usize; 3]>,+ pub viewport: ViewportTransform,+ pub frozen: bool,+ pub zmode: ZMode,+ pub z_texture: bool,+ pub depth_before: OnceLock<Option<Vec<u32>>>,+ pub reference: Option<Reference>,+ pub last_plane: Option<([usize; 3], DepthPlane)>,+ pub texture: Option<Arc<egui::ColorImage>>,+ pub texture_wrap: egui::TextureWrapMode,+}++#[derive(Default)]+pub struct GeometryCapture {+ pub location: DrawLocation,+ pub draws: HashMap<usize, Vec<Arc<Geometry>>>,+ pub reference: Option<Reference>,+ textures: HashMap<TextureKey, Arc<egui::ColorImage>>,+ bindings: [Option<TextureKey>; 8],+}++impl GeometryCapture {+ pub fn action(&mut self, action: &GxAction) {+ match action {+ GxAction::LoadTexture {+ id,+ width,+ height,+ rgba,+ ..+ } => {+ let size = [*width as usize, *height as usize];++ if !rgba.is_empty() && rgba.len() == size[0] * size[1] * 4 {+ let image = egui::ColorImage::from_rgba_unmultiplied(size, rgba);+ self.textures.insert(*id, Arc::new(image));+ } else {+ self.textures.remove(id);+ }+ }+ GxAction::SetTexture { slot, id, .. } => self.bindings[*slot] = Some(*id),+ GxAction::InvalidateCaches => {+ self.textures.clear();+ self.bindings.fill(None);+ }++ _ => {}+ }+ }++ pub fn record(&mut self, gx: &GraphicsProcessor, primitive: Primitive, verts: &[DrawVertex]) {+ let gen_mode = GenMode::from_raw(gx.bp_regs[BP_GEN_MODE]);+ let stages = gen_mode.num_tev_stages() as usize + 1;++ let orders = gx.resolve_tev_orders();+ let texture_stage = orders[..stages]+ .iter()+ .find(|order| order.tex_enable())+ .map(|order| (order.texmap() as usize, order.texcoord() as usize));++ let texture = texture_stage.and_then(|(slot, _)| self.textures.get(&self.bindings[slot]?).cloned());++ let texture_wrap = match texture_stage.and_then(|(slot, _)| gx.cur_textures[slot]) {+ Some(desc) if desc.wrap_s == WrapMode::Repeat => egui::TextureWrapMode::Repeat,+ Some(desc) if desc.wrap_s == WrapMode::Mirror => egui::TextureWrapMode::MirroredRepeat,+ _ => egui::TextureWrapMode::ClampToEdge,+ };++ let vertices: Vec<_> = verts+ .iter()+ .map(|v| {+ let mut stq = texture_stage.map_or(Vec3::Z, |(_, coord)| Vec3::from_array(v.texcoords[coord]));++ if stq.z.abs() < f32::EPSILON {+ stq.z = 1.0;+ }++ Vertex {+ clip: gx.clip_position(v.pos_view),+ stq,+ }+ })+ .collect();++ let viewport = gx.viewport_transform();+ let vertex_count = verts.len() as u32;++ let triangles: Vec<_> = primitive+ .triangles(vertex_count)+ .map(|t| t.map(|i| i as usize))+ .collect();++ let last_plane = DepthPlane::last_triangle(primitive, vertex_count, viewport, |i| vertices[i as usize].clip)+ .map(|(t, plane)| (t.map(|i| i as usize), plane));++ let frozen = gen_mode.z_freeze();+ let draws = self.draws.entry(self.location.offset).or_default();++ let geometry = Arc::new(Geometry {+ location: self.location,+ subdraw: draws.len(),+ vertices,+ triangles,+ viewport,+ frozen,+ zmode: gx.cur_zmode,+ z_texture: gx.effective_ztex_op() != 0,+ depth_before: OnceLock::new(),+ reference: frozen.then(|| self.reference.clone()).flatten(),+ last_plane,+ texture,+ texture_wrap,+ });++ if !frozen && let Some((triangle, plane)) = last_plane {+ self.reference = Some(Reference {+ draw: geometry.clone(),+ triangle,+ plane,+ });+ }++ draws.push(geometry);+ }+}++pub(super) fn clip_polygon<T: Copy, P: Copy>(+ mut polygon: Vec<T>,+ planes: impl IntoIterator<Item = P>,+ distance: impl Fn(T, P) -> f32,+ lerp: impl Fn(T, T, f32) -> T,+) -> Vec<T> {+ let mut input = Vec::with_capacity(polygon.len() + 1);++ for plane in planes {+ std::mem::swap(&mut input, &mut polygon);+ polygon.clear();++ for i in 0..input.len() {+ let a = input[i];+ let b = input[(i + 1) % input.len()];++ let da = distance(a, plane);+ let db = distance(b, plane);++ if da >= 0.0 {+ polygon.push(a);+ }++ if (da < 0.0) != (db < 0.0) {+ polygon.push(lerp(a, b, da / (da - db)));+ }+ }++ if polygon.is_empty() {+ break;+ }+ }++ polygon+}++impl Geometry {+ pub fn projected_vertices(&self, triangle: [usize; 3]) -> Vec<ProjectedVertex> {+ let polygon: Vec<_> = triangle.map(|i| (self.vertices[i].clip, self.vertices[i].stq)).into();++ if polygon.iter().any(|(p, _)| !p.is_finite()) {+ return Vec::new();+ }++ let polygon = self::clip_polygon(+ polygon,+ 0..6,+ |(p, _), plane| depth::clip_distance(p, plane),+ |a, b, t| (a.0.lerp(b.0, t), a.1.lerp(b.1, t)),+ );++ polygon+ .into_iter()+ .filter(|(p, _)| p.w > 0.0)+ .map(|(p, stq)| ProjectedVertex {+ screen: self.viewport.to_screen(p),+ stq: stq / p.w,+ })+ .collect()+ }+}diff --git a/crates/fifoplayer/src/debug/ui.rs b/crates/fifoplayer/src/debug/ui.rsindex 1ef4496..21dbf03 100644--- a/crates/fifoplayer/src/debug/ui.rs+++ b/crates/fifoplayer/src/debug/ui.rs@@ -21,6 +21,7 @@ enum ViewMode {Auto,Efb,Xfb,+ Depth,}#[derive(Copy, Clone, PartialEq, Eq)]@@ -47,6 +48,8 @@ enum Row {}enum UiAction {+ SelectDraw(usize),+ CaptureDepth,StepCmd,StepDraw,StepFrame,@@ -116,6 +119,8 @@ pub fn run_debug<const SYSTEM: SystemId>(file: dff::DffFile, path: PathBuf, starhex_for: None,bp_input: String::new(),status_msg: String::new(),+ geometry_subdraw: 0,+ depth_view: super::depth_view::DepthView::default(),};let event_loop = EventLoop::new().unwrap();@@ -184,6 +189,8 @@ struct DebugApp<const SYSTEM: SystemId> {hex_for: Option<usize>,bp_input: String,status_msg: String,+ geometry_subdraw: usize,+ depth_view: super::depth_view::DepthView,}const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8Unorm;@@ -268,6 +275,37 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {fn apply_action(&mut self, action: UiAction) {let mut stepped = true;match action {+ UiAction::CaptureDepth => {+ if let Some(draw) = self.selected_geometry() {+ self.session.sink.depth_request = Some((draw.location, draw.subdraw));+ self.session.rerender();+ self.session.sink.depth_request = None;+ }+ }+ UiAction::SelectDraw(row) => {+ self.select_row(row);++ let eligible = self.session.index.commands.get(row).is_some_and(|cmd| {+ matches!(cmd.kind, CmdKind::Draw { .. } | CmdKind::CallDl { .. })+ && !self.session.cur.disabled.contains(&cmd.offset)+ });++ if !eligible {+ stepped = false;+ } else if self.selected_geometry().is_some() {+ self.session.pause();+ stepped = false;+ } else {+ let frame = self.session.frame_idx;+ let ahead = !self.session.finished && row + 1 >= self.session.row;++ self.session.jump_to(frame, row + 1);++ if ahead {+ self::rerender_if_in_frame(&mut self.session, frame);+ }+ }+ }UiAction::StepCmd => {let f0 = self.session.frame_idx;self.session.step_command();@@ -307,7 +345,15 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {}UiAction::Restart => self.session.restart(),UiAction::RestartFrame => self.session.restart_frame(),- UiAction::JumpTo(frame, row) => self.session.jump_to(frame, row),+ UiAction::JumpTo(frame, row) => {+ self.session.jump_to(frame, row);++ if self.view_mode == ViewMode::Depth {+ self.apply_action(UiAction::SelectDraw(row));+ } else {+ self.select_row(row);+ }+ }UiAction::ToggleDisabled(off) => self.session.toggle_disabled(off),UiAction::ToggleRowBp(row) => {stepped = false;@@ -376,7 +422,7 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {self.frame_panel(ui, actions);self.command_panel(ui, actions);self.inspector_panel(ui, actions);- self.game_panel(ui);+ self.game_panel(ui, actions);}fn toolbar(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {@@ -443,11 +489,20 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {ViewMode::Auto => "Auto",ViewMode::Efb => "EFB",ViewMode::Xfb => "XFB",+ ViewMode::Depth => "Depth",}).show_ui(ui, |ui| {ui.selectable_value(&mut self.view_mode, ViewMode::Auto, "Auto");ui.selectable_value(&mut self.view_mode, ViewMode::Efb, "EFB");ui.selectable_value(&mut self.view_mode, ViewMode::Xfb, "XFB");++ if ui+ .selectable_value(&mut self.view_mode, ViewMode::Depth, "Depth")+ .changed()+ && let Selection::Cmd(row) = self.selection+ {+ actions.push(UiAction::SelectDraw(row));+ }});ui.separator();@@ -713,7 +768,12 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {}if ui.selectable_label(is_selected, text).clicked() {- self.selection = Selection::Cmd(i);+ if self.view_mode == ViewMode::Depth {+ actions.push(UiAction::SelectDraw(i));+ } else {+ self.selection = Selection::Cmd(i);+ self.geometry_subdraw = 0;+ }}});}@@ -725,7 +785,7 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {.resizable(true).default_size(360.0).show_inside(root, |ui| {- ui.horizontal(|ui| {+ ui.horizontal_wrapped(|ui| {ui.selectable_value(&mut self.inspector_tab, Tab::Disasm, "Disasm");ui.selectable_value(&mut self.inspector_tab, Tab::Registers, "Registers");ui.selectable_value(&mut self.inspector_tab, Tab::Hex, "Hex");@@ -739,7 +799,7 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {Tab::Disasm => self.disasm_tab(ui),Tab::Registers => self.registers_tab(ui),Tab::Hex => self.hex_tab(ui, actions),- Tab::Breakpoints => self.breakpoints_tab(ui),+ Tab::Breakpoints => self.breakpoints_tab(ui, actions),});});}@@ -760,6 +820,34 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {}}+ fn select_row(&mut self, row: usize) {+ self.selection = Selection::Cmd(row);+ self.geometry_subdraw = 0;+ }++ fn selected_draws(&self) -> Option<&[Arc<super::geometry::Geometry>]> {+ let Selection::Cmd(row) = self.selection else {+ return None;+ };++ let cmd = self.session.index.commands.get(row)?;++ self.session+ .sink+ .inspection+ .as_ref()?+ .draws+ .get(&cmd.offset)+ .map(Vec::as_slice)+ }++ fn selected_geometry(&self) -> Option<Arc<super::geometry::Geometry>> {+ let draws = self.selected_draws()?;+ let idx = self.geometry_subdraw.min(draws.len().saturating_sub(1));++ draws.get(idx).cloned()+ }+fn registers_tab(&self, ui: &mut egui::Ui) {let gx = &self.session.playback.gx;@@ -881,7 +969,7 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {);}- fn breakpoints_tab(&mut self, ui: &mut egui::Ui) {+ fn breakpoints_tab(&mut self, ui: &mut egui::Ui, actions: &mut Vec<UiAction>) {let bp = &mut self.session.breakpoints;ui.label(egui::RichText::new("Break on command kind").strong());@@ -893,32 +981,42 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {ui.checkbox(&mut bp.on_xf, "any XF write");ui.separator();- ui.label(egui::RichText::new("Register breakpoints").strong());- ui.label(egui::RichText::new("cp <hex> | bp <hex> | xf <hex>").weak());+ ui.label(egui::RichText::new("Add breakpoint").strong());+ ui.label(egui::RichText::new("cmd <hex offset> (current frame)\ncp <hex> | bp <hex> | xf <hex>").weak());ui.horizontal(|ui| {- ui.add(egui::TextEdit::singleline(&mut self.bp_input).desired_width(120.0));-- if ui.button(format!("{} Add", icons::PLUS)).clicked() {- let input = self.bp_input.trim().to_lowercase();- let mut parts = input.split_whitespace();- let kind = parts.next().unwrap_or("");- let val = parts.next().and_then(|v| u16::from_str_radix(v, 16).ok());-- match (kind, val) {- ("cp", Some(v)) if v <= 0xFF => {- bp.cp_regs.insert(v as u8);- self.bp_input.clear();- }- ("bp", Some(v)) if v <= 0xFF => {- bp.bp_regs.insert(v as u8);- self.bp_input.clear();- }- ("xf", Some(v)) => {- bp.xf_addrs.insert(v);- self.bp_input.clear();+ let input = ui.add(+ egui::TextEdit::singleline(&mut self.bp_input)+ .hint_text("cmd 0186A3")+ .desired_width(170.0),+ );++ let enter = input.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));++ if ui.button(format!("{} Add", icons::PLUS)).clicked() || enter {+ let frame = self.session.frame_idx;++ let added = match super::parse_breakpoint(&self.bp_input) {+ Ok(super::BreakpointSpec::Cp(v)) => Ok(bp.cp_regs.insert(v)),+ Ok(super::BreakpointSpec::Bp(v)) => Ok(bp.bp_regs.insert(v)),+ Ok(super::BreakpointSpec::Xf(v)) => Ok(bp.xf_addrs.insert(v)),+ Ok(super::BreakpointSpec::Command(offset)) => {+ let row = self.session.index.commands.iter().position(|c| c.offset == offset);++ match row {+ Some(row) => {+ self.status_msg = format!("Breakpoint: frame {frame} / {offset:06X}");+ Ok(bp.rows.insert((frame, row)))+ }+ None => Err(format!("{offset:06X} is not within boundary in this frame")),+ }}- _ => self.status_msg = "expected: cp|bp|xf <hex>".into(),+ Err(err) => Err(err.into()),+ };++ match added {+ Ok(_) => self.bp_input.clear(),+ Err(msg) => self.status_msg = msg,}}});@@ -939,7 +1037,21 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {for (frame, row) in rows {ui.horizontal(|ui| {- ui.label(egui::RichText::new(format!("frame {frame} cmd {row}")).monospace());+ let label = self+ .session+ .index+ .commands+ .get(row)+ .filter(|_| frame == self.session.frame_idx)+ .map(|c| format!("frame {frame} / {:06X}", c.offset))+ .unwrap_or_else(|| format!("frame {frame} cmd {row}"));++ ui.label(egui::RichText::new(label).monospace());++ if ui.small_button("Go").clicked() {+ actions.push(UiAction::JumpTo(frame, row));+ }+if ui.small_button(icons::TRASH).clicked() {remove_row = Some((frame, row));}@@ -952,11 +1064,38 @@ impl<const SYSTEM: SystemId> DebugApp<SYSTEM> {}}- fn game_panel(&mut self, root: &mut egui::Ui) {+ fn game_panel(&mut self, root: &mut egui::Ui, actions: &mut Vec<UiAction>) {egui::CentralPanel::default().show_inside(root, |ui| {+ if self.view_mode == ViewMode::Depth {+ let num_draws = self.selected_draws().map_or(0, |draws| draws.len());++ if num_draws > 1 {+ ui.horizontal(|ui| {+ ui.label("Draw");+ ui.add(egui::DragValue::new(&mut self.geometry_subdraw).range(0..=num_draws - 1));+ ui.weak(format!("/ {}", num_draws - 1));+ });+ }++ let selected = self.selected_geometry();++ if let Some(capture) = &self.session.sink.inspection {+ self.depth_view.show(ui, capture, selected.as_ref());+ }++ if self.depth_view.show_test+ && self.session.run_state == RunState::Paused+ && selected.as_ref().is_some_and(|d| d.depth_before.get().is_none())+ {+ actions.push(UiAction::CaptureDepth);+ }++ return;+ }+let show_xfb = match self.view_mode {ViewMode::Xfb => true,- ViewMode::Efb => false,+ ViewMode::Efb | ViewMode::Depth => false,ViewMode::Auto => (self.session.row == 0 || self.session.finished) && self.session.presents > 0,};@@ -1225,6 +1364,11 @@ impl<const SYSTEM: SystemId> ApplicationHandler for DebugApp<SYSTEM> {WindowEvent::RedrawRequested => {if self.session.run_state != RunState::Paused {self.session.run_tick();++ if self.session.run_state == RunState::Paused && !self.session.finished {+ self.select_row(self.session.row);+ }+self.flush_gx();self.scroll_to_current = true;}diff --git a/crates/fifoplayer/src/playback.rs b/crates/fifoplayer/src/playback.rsindex 847ae35..2cd6e80 100644--- a/crates/fifoplayer/src/playback.rs+++ b/crates/fifoplayer/src/playback.rs@@ -1,6 +1,6 @@use gecko::flipper::gx::constants::{BP_REG_SIZE, CP_REG_SIZE};use gecko::flipper::gx::{GraphicsProcessor, texture};-use gecko::host::{DrawData, DrawVertex, GxAction, RenderSink, XfbPart};+use gecko::host::{DrawData, DrawSegment, DrawVertex, GxAction, RenderSink, XfbPart};use gecko::mmio::{Mmio, RamViewMut};use gecko::system::SystemId;@@ -9,6 +9,9 @@ const BP_RESTORE_SKIP: &[usize] = &[0x45, 0x47, 0x48, 0x52, 0x65, 0xFE];pub struct PlayerSink {inner: Box<dyn RenderSink>,xfb_heights: Vec<(u32, u32)>,+ pub inspection: Option<crate::debug::geometry::GeometryCapture>,+ pub depth_request: Option<(crate::debug::geometry::DrawLocation, usize)>,+ next_subdraw: usize,}impl PlayerSink {@@ -16,15 +19,54 @@ impl PlayerSink {PlayerSink {inner,xfb_heights: Vec::new(),+ inspection: None,+ depth_request: None,+ next_subdraw: 0,}}}impl RenderSink for PlayerSink {+ fn capture_efb_depth(&mut self) -> Option<Vec<u32>> {+ self.inner.capture_efb_depth()+ }++ fn inspect_draws(&mut self, gx: &GraphicsProcessor, segments: &[DrawSegment]) {+ let Some(capture) = &mut self.inspection else {+ return;+ };++ let verts = self.inner.vertex_scratch();+ self.next_subdraw = capture.draws.get(&capture.location.offset).map_or(0, Vec::len);++ for seg in segments {+ let first = seg.base_vertex as usize;+ capture.record(gx, seg.primitive, &verts[first..first + seg.vertex_count as usize]);+ }+ }+fn exec(&mut self, action: GxAction) {+ if let GxAction::Draw(data) = &action {+ if let Some(capture) = &self.inspection+ && self.depth_request == Some((capture.location, self.next_subdraw))+ && let Some(draw) = capture+ .draws+ .get(&capture.location.offset)+ .and_then(|v| v.get(self.next_subdraw))+ {+ let _ = draw.depth_before.set(self.inner.capture_efb_depth());+ }+ self.next_subdraw += data.segments.len();+ }++ if let Some(capture) = &mut self.inspection {+ capture.action(&action);+ }+if let GxAction::CopyXfb { id, dst_h, .. } = &action {self.xfb_heights.push((*id, *dst_h));}+self.inner.exec(action);}@@ -110,13 +152,10 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {}pub fn play_frame(&mut self, frame: &dff::Frame, sink: &mut PlayerSink) -> bool {- self.play_frame_with(&frame.fifo_data, &frame.memory_updates, sink)- }-- pub fn play_frame_with(&mut self, fifo_data: &[u8], updates: &[dff::MemoryUpdate], sink: &mut PlayerSink) -> bool {+ let fifo_data = &frame.fifo_data;let mut pos = 0usize;- for update in updates {+ for update in &frame.memory_updates {let p = (update.fifo_position as usize).min(fifo_data.len());if p > pos {self.feed(&fifo_data[pos..p], sink);diff --git a/crates/gecko/Cargo.toml b/crates/gecko/Cargo.tomlindex a32caf6..a40e558 100644--- a/crates/gecko/Cargo.toml+++ b/crates/gecko/Cargo.toml@@ -37,7 +37,7 @@ dff = { path = "../dff" }tracing = "0.1.44"image = { path = "../image", default-features = false }disasm = { path = "../disasm" }-glam = { version = "0.32.1", features = ["bytemuck"] }+glam = { version = "0.33.7", features = ["bytemuck"] }bytemuck = { version = "1.25.0", features = ["derive"] }twox-hash = "2.1.2"crossbeam-channel = "0.5.15"diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex 9766986..3d50b21 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -1,5 +1,6 @@mod bp;pub mod constants;+pub mod depth;pub mod draw;pub mod fifo;#[cfg(feature = "jit")]@@ -28,6 +29,7 @@ pub struct GraphicsProcessor {pub pending_token: u16,pub token_dirty: bool,pub projection: Matrix4,+ pub zfreeze_plane: depth::DepthPlane,pub bp_regs: Vec<u32>,pub bp_mask: u32,pub cp_regs: Vec<u32>,@@ -184,6 +186,7 @@ impl GraphicsProcessor {pending_efb_writeback_ranges: Vec::new(),recorder: None,projection: Matrix4::default(),+ zfreeze_plane: depth::DepthPlane::default(),cur_textures: Default::default(),tex_dirty: 0,cur_tluts: [draw::TlutRef::default(); 8],diff --git a/crates/gecko/src/flipper/gx/depth.rs b/crates/gecko/src/flipper/gx/depth.rsnew file mode 100644index 0000000..b5561e3--- /dev/null+++ b/crates/gecko/src/flipper/gx/depth.rs@@ -0,0 +1,138 @@+use super::GraphicsProcessor;+use super::constants::*;+use super::draw::Primitive;+use glam::{Mat4, Vec3, Vec4};++#[repr(C)]+#[derive(Clone, Copy, Debug, Default, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]+pub struct DepthPlane {+ pub dx: f32,+ pub dy: f32,+ pub c: f32,+}++#[derive(Clone, Copy, Debug)]+pub struct ViewportTransform {+ pub scale: Vec3,+ pub offset: Vec3,+}++impl ViewportTransform {+ pub fn to_screen(self, clip: Vec4) -> Vec3 {+ clip.truncate() / clip.w * self.scale + self.offset+ }+}++pub fn clip_distance(clip: Vec4, plane: usize) -> f32 {+ let [x, y, z, w] = clip.to_array();+ [x + w, w - x, y + w, w - y, z + w, -z][plane]+}++impl DepthPlane {+ pub fn from_points(points: [Vec3; 3]) -> Option<Self> {+ let [a, b, c] = points;+ let normal = (b - a).cross(c - a);++ if normal.z == 0.0 {+ return None;+ }++ let dx = -normal.x / normal.z;+ let dy = -normal.y / normal.z;++ let plane = Self {+ dx,+ dy,+ c: a.z - dx * a.x - dy * a.y,+ };++ plane.to_array().iter().all(|v| v.is_finite()).then_some(plane)+ }++ pub fn from_clip_triangle(clip: [Vec4; 3], viewport: ViewportTransform) -> Option<Self> {+ let clipped = (0..6).any(|p| clip.iter().all(|&v| self::clip_distance(v, p) < 0.0));++ if clipped {+ return None;+ }++ Self::from_points(clip.map(|v| viewport.to_screen(v)))+ }++ pub fn last_triangle(+ primitive: Primitive,+ vertex_count: u32,+ viewport: ViewportTransform,+ clip: impl Fn(u32) -> Vec4,+ ) -> Option<([u32; 3], Self)> {+ (0..primitive.triangle_count(vertex_count)).rev().find_map(|i| {+ let triangle = primitive.triangle(i);++ Self::from_clip_triangle(triangle.map(&clip), viewport).map(|plane| (triangle, plane))+ })+ }++ pub fn eval(self, x: f32, y: f32) -> f32 {+ self.dx * x + self.dy * y + self.c+ }++ pub fn to_array(self) -> [f32; 3] {+ [self.dx, self.dy, self.c]+ }+}++impl GraphicsProcessor {+ pub fn viewport_transform(&self) -> ViewportTransform {+ let vp = self.cur_viewport;++ ViewportTransform {+ scale: Vec3::new(+ vp.w * 0.5,+ vp.h * -0.5,+ f32::from_bits(self.xf_mem[XF_VIEWPORT_SCALE_Z]),+ ),+ offset: Vec3::new(+ vp.x + vp.w * 0.5,+ vp.y + vp.h * 0.5,+ f32::from_bits(self.xf_mem[XF_VIEWPORT_OFFSET_Z]),+ ),+ }+ }++ pub fn clip_position(&self, pos_view: [f32; 3]) -> Vec4 {+ Mat4::from_cols_array_2d(&self.projection.0) * Vec3::from_array(pos_view).extend(1.0)+ }++ pub fn effective_ztex_op(&self) -> u8 {+ if self.cur_pe_control.early_ztest() {+ 0+ } else {+ super::regs::TevZtex2::from_raw(self.bp_regs[BP_TEV_ZTEX2]).op()+ }+ }++ pub(super) fn update_depth_plane(+ &mut self,+ entries: &[super::vertex::DrawBatchEntry],+ vertices: &[crate::host::DrawVertex],+ ) {+ let viewport = self.viewport_transform();+ let mut end = vertices.len();++ for entry in entries.iter().rev() {+ let start = end - entry.vertex_count;+ end = start;++ let Some(primitive) = Primitive::from_cmd(entry.cmd) else {+ continue;+ };++ let clip = |j: u32| self.clip_position(vertices[start + j as usize].pos_view);++ if let Some((_, plane)) = DepthPlane::last_triangle(primitive, entry.vertex_count as u32, viewport, clip) {+ self.zfreeze_plane = plane;+ return;+ }+ }+ }+}diff --git a/crates/gecko/src/flipper/gx/draw.rs b/crates/gecko/src/flipper/gx/draw.rsindex 7a2e6ce..8f87767 100644--- a/crates/gecko/src/flipper/gx/draw.rs+++ b/crates/gecko/src/flipper/gx/draw.rs@@ -31,6 +31,44 @@ impl Primitive {}}}++ pub fn emits_triangles(self) -> bool {+ self.triangle_count(3) != 0+ }++ pub fn triangle_count(self, vertex_count: u32) -> u32 {+ let n = vertex_count;++ match self {+ Primitive::Triangles => n / 3,+ Primitive::Quads => n / 4 * 2 + (n % 4 == 3) as u32,+ Primitive::TriangleStrip | Primitive::TriangleFan => n.saturating_sub(2),+ _ => 0,+ }+ }++ pub fn triangle(self, i: u32) -> [u32; 3] {+ match self {+ Primitive::Triangles => [3 * i, 3 * i + 1, 3 * i + 2],+ Primitive::Quads => {+ let base = i / 2 * 4;++ if i & 1 == 0 {+ [base, base + 1, base + 2]+ } else {+ [base, base + 2, base + 3]+ }+ }+ Primitive::TriangleStrip if i & 1 == 0 => [i, i + 1, i + 2],+ Primitive::TriangleStrip => [i + 1, i, i + 2],+ Primitive::TriangleFan => [0, i + 1, i + 2],+ _ => unreachable!("{self:?} has no triangles"),+ }+ }++ pub fn triangles(self, vertex_count: u32) -> impl Iterator<Item = [u32; 3]> {+ (0..self.triangle_count(vertex_count)).map(move |i| self.triangle(i))+ }}#[derive(Debug)]diff --git a/crates/gecko/src/flipper/gx/regs.rs b/crates/gecko/src/flipper/gx/regs.rsindex 33d48ba..7a88907 100644--- a/crates/gecko/src/flipper/gx/regs.rs+++ b/crates/gecko/src/flipper/gx/regs.rs@@ -908,6 +908,8 @@ pub struct GenMode {pub cull_mode: CullMode,#[bits(16..=18)]pub num_ind_stages: u8,+ #[bits(19)]+ pub z_freeze: bool,}#[derive(Debug, PartialEq, BitEnum)]diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rsindex 87945ac..2d02526 100644--- a/crates/gecko/src/flipper/gx/vertex.rs+++ b/crates/gecko/src/flipper/gx/vertex.rs@@ -137,6 +137,12 @@ impl GraphicsProcessor {verts.reserve(vertex_count);self::dispatch_decode(self, mmio, cmd, data, vertex_count, verts);+ let zfreeze = GenMode::from_raw(self.bp_regs[BP_GEN_MODE]).z_freeze();++ if !zfreeze {+ self.update_depth_plane(entries, &verts[base_vertex as usize..]);+ }+let state = self.frame_state_dirty.then(|| {let tev_color_regs = self.resolve_tev_color_regs();let tev_orders = self.resolve_tev_orders();@@ -176,6 +182,7 @@ impl GraphicsProcessor {let ztex2 = TevZtex2::from_raw(self.bp_regs[BP_TEV_ZTEX2]);DrawState {+ zfreeze: zfreeze.then_some(self.zfreeze_plane),tev_color_env: std::array::from_fn(|i| self.cur_tev_color_env[i].raw()),tev_alpha_env: std::array::from_fn(|i| self.cur_tev_alpha_env[i].raw()),tev_orders: std::array::from_fn(|i| tev_orders[i].raw()),@@ -197,11 +204,7 @@ impl GraphicsProcessor {active_texcoords: (self.xf_mem[crate::flipper::gx::constants::XF_NUM_TEXGENS] as u8).min(8),ztex_bias: TevZtex1::from_raw(self.bp_regs[BP_TEV_ZTEX1]).bias(),ztex_type: ztex2.tex_type(),- ztex_op: if self.cur_pe_control.early_ztest() {- 0- } else {- ztex2.op()- },+ ztex_op: self.effective_ztex_op(),}});self.frame_state_dirty = false;@@ -224,6 +227,8 @@ impl GraphicsProcessor {segment_base = segment_base.wrapping_add(entry.vertex_count as u32);}+ renderer.inspect_draws(self, &self.draw_segments_scratch);+renderer.exec_draw_batch(&self.draw_segments_scratch, state);#[cfg(feature = "gx-stats")]diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex d3c04ba..431ca1e 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -182,6 +182,7 @@ pub struct DrawData {#[derive(Debug, Clone, Default)]pub struct DrawState {pub active_texcoords: u8,+ pub zfreeze: Option<crate::flipper::gx::depth::DepthPlane>,// TEV combiner statepub tev_color_env: [u32; 16],pub tev_alpha_env: [u32; 16],@@ -286,6 +287,10 @@ pub trait RenderSink: Send {0x00FF_FFFF}+ fn capture_efb_depth(&mut self) -> Option<Vec<u32>> {+ None+ }+fn exec_draw(&mut self, segment: DrawSegment, state: Option<DrawState>) {let mut draw = self.take_draw_data();draw.segments.clear();@@ -302,6 +307,8 @@ pub trait RenderSink: Send {fn vertex_scratch(&mut self) -> &mut Vec<DrawVertex>;+ fn inspect_draws(&mut self, _gx: &crate::flipper::gx::GraphicsProcessor, _segments: &[DrawSegment]) {}+fn has_pending_efb_texture(&self, _addr: u32, _width: u32, _height: u32, _fmt: TextureFormat) -> bool {false}diff --git a/crates/gecko/src/savestate.rs b/crates/gecko/src/savestate.rsindex fef7d2f..d28f751 100644--- a/crates/gecko/src/savestate.rs+++ b/crates/gecko/src/savestate.rs@@ -2,7 +2,7 @@ use crate::system::{System, SystemId, WII};use std::path::PathBuf;pub const STATE_MAGIC: [u8; 4] = *b"GKST";-pub const STATE_VERSION: u32 = 2;+pub const STATE_VERSION: u32 = 3;const COMPRESSION_LEVEL: i32 = 1;@@ -276,6 +276,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {// Version 2 appends the DSP exception latch to preserve version 1 layoutsw.u8(self.dsp.pending_exceptions);+ w.pod(&self.gx.zfreeze_plane);self::pack(SYSTEM, &w.into_inner())}@@ -313,6 +314,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {}self.dsp.pending_exceptions = if version >= 2 { r.u8()? } else { 0 };+ self.gx.zfreeze_plane = if version >= 3 { r.pod()? } else { Default::default() };if r.remaining() != 0 {return Err(StateError::Corrupt("trailing data"));