Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

23.1 KB
Raw Blame
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);
        }
    }
}