Skip to content

armgit / gecko

Public Imported from GitHub
0

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.lock
index 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.toml
index 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.rs
index 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::Al
ztex_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.wesl
index 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.wesl
index 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.rs
index 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.toml
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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, star
hex_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.rs
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 state
pub 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.rs
index 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 layouts
w.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"));