topola/topola-egui/src/viewport.rs

// SPDX-FileCopyrightText: 2026 Topola contributors
//
// SPDX-License-Identifier: MIT OR Apache-2.0

use egui::Pos2;
use topola::Vector2;

use crate::{display::Display, workspace::Workspace};

pub struct Viewport {
    pub scene_rect: egui::Rect,
    pub ref_scene_rect: egui::Rect,
    pub scheduled_zoom_to_fit: bool,
}

impl Viewport {
    pub fn new() -> Self {
        Self {
            scene_rect: egui::Rect::from_min_max(egui::pos2(-1.0, -1.0), egui::pos2(1.0, 1.0)),
            ref_scene_rect: egui::Rect::from_min_max(egui::pos2(-1.0, -1.0), egui::pos2(1.0, 1.0)),
            scheduled_zoom_to_fit: false,
        }
    }

    pub fn update(&mut self, ctx: &egui::Context, workspace: Option<&mut Workspace>) {
        egui::CentralPanel::default().show(ctx, |ui| {
            egui::Frame::canvas(ui.style()).show(ui, |ui| {
                ui.ctx().request_repaint();

                let zoom_range = 0.00001..=10000.0;

                let viewport_rect = ui.available_rect_before_wrap();
                let mut scene_rect = self.scene_rect.clone();

                let response = egui::Scene::new()
                    .zoom_range(zoom_range.clone())
                    //.sense(egui::Sense::hover())
                    .show(ui, &mut scene_rect, |ui| {
                        if let Some(ref workspace) = workspace {
                            let mut display = Display::new();
                            display.update(ctx, ui, &self, workspace);
                        }
                    })
                    .response;

                self.scene_rect = scene_rect;

                let scene_to_viewport =
                    Self::fit_to_rect_in_scene(viewport_rect, scene_rect, zoom_range.into());

                if let Some(workspace) = workspace {
                    if let Some(pointer_viewport_pos) = ctx.input(|i| i.pointer.interact_pos()) {
                        let pointer_scene_pos = scene_to_viewport.inverse() * pointer_viewport_pos;

                        if response.clicked() {
                            if let Some(pin_selector) = workspace
                                .autorouter
                                .router()
                                .navmesher_board()
                                .board()
                                .locate_pin_at_point(
                                    workspace.appearance_panel.active,
                                    Vector2::new(
                                        pointer_scene_pos.x as i64,
                                        pointer_scene_pos.y as i64,
                                    ),
                                )
                            {
                                workspace.selection.pins.toggle(pin_selector);
                            }
                        }
                    }

                    self.zoom_to_fit_if_scheduled(workspace);
                }
            })
        });
    }

    /// Copied from egui/containers/scene.rs and modified.
    ///
    /// Creates a transformation that fits a given scene rectangle into the available screen size.
    ///
    /// The resulting visual scene bounds can be larger, due to letterboxing.
    ///
    /// Returns the transformation from `scene` to `global` coordinates.
    fn fit_to_rect_in_scene(
        rect_in_viewport: egui::Rect,
        rect_in_scene: egui::Rect,
        zoom_range: egui::Rangef,
    ) -> egui::emath::TSTransform {
        // Compute the scale factor to fit the bounding rectangle into the available screen size:
        let scale = rect_in_viewport.size() / rect_in_scene.size();

        // Use the smaller of the two scales to ensure the whole rectangle fits on the screen:
        let scale = scale.min_elem();

        // Clamp scale to what is allowed
        let scale = zoom_range.clamp(scale);

        // Compute the translation to center the bounding rect in the screen:
        let center_in_global = rect_in_viewport.center().to_vec2();
        let center_scene = rect_in_scene.center().to_vec2();

        // Set the transformation to scale and then translate to center.
        egui::emath::TSTransform::from_translation(center_in_global - scale * center_scene)
            * egui::emath::TSTransform::from_scaling(scale)
    }

    fn zoom_to_fit_if_scheduled(&mut self, workspace: &Workspace) {
        if self.scheduled_zoom_to_fit {
            self.scene_rect = Self::boundary_bounding_box(workspace);
            self.ref_scene_rect = self.scene_rect.clone();
        }

        self.scheduled_zoom_to_fit = false;
    }

    fn boundary_bounding_box(workspace: &Workspace) -> egui::Rect {
        let first = workspace
            .autorouter
            .router()
            .navmesher_board()
            .board()
            .layout()
            .boundary()[0];

        let mut min_x = first[0];
        let mut max_x = first[0];
        let mut min_y = first[1];
        let mut max_y = first[1];

        for point in workspace
            .autorouter
            .router()
            .navmesher_board()
            .board()
            .layout()
            .boundary()[1..]
            .iter()
        {
            if point[0] < min_x {
                min_x = point[0];
            }
            if point[0] > max_x {
                max_x = point[0];
            }
            if point[1] < min_y {
                min_y = point[1];
            }
            if point[1] > max_y {
                max_y = point[1];
            }
        }

        egui::Rect::from_min_max(
            Pos2::new(min_x as f32, min_y as f32),
            Pos2::new(max_x as f32, max_y as f32),
        )
        .scale_from_center(1.05)
    }

    pub fn scale_factor(&self) -> f32 {
        self.ref_scene_rect.width() / self.scene_rect.width()
    }
}