From 47c888d21b7991d32183908de0deb9af5b08e2cb Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Mon, 1 Jul 2024 18:56:41 +0200 Subject: [PATCH] egui,autorouter,router: restore highlighting active navmesh edges --- src/autorouter/autoroute.rs | 17 ++++++++++++++-- src/autorouter/invoker.rs | 15 ++++++++++++-- src/autorouter/place_via.rs | 13 ++++++++++-- src/bin/topola-egui/viewport.rs | 35 ++++++++++++++++++--------------- src/router/navmesh.rs | 32 +++++++++++++++--------------- src/router/route.rs | 12 +++++++---- 6 files changed, 82 insertions(+), 42 deletions(-) diff --git a/src/autorouter/autoroute.rs b/src/autorouter/autoroute.rs index 077eaef..7ba1543 100644 --- a/src/autorouter/autoroute.rs +++ b/src/autorouter/autoroute.rs @@ -1,9 +1,12 @@ use petgraph::graph::EdgeIndex; use crate::{ - autorouter::{invoker::GetMaybeNavmesh, Autorouter, AutorouterError, AutorouterStatus}, + autorouter::{ + invoker::{GetMaybeNavmesh, GetMaybeTrace}, + Autorouter, AutorouterError, AutorouterStatus, + }, board::mesadata::MesadataTrait, - router::{navmesh::Navmesh, route::Route, Router, RouterStatus}, + router::{navmesh::Navmesh, route::Route, trace::Trace, Router, RouterStatus}, }; pub struct Autoroute { @@ -84,6 +87,10 @@ impl Autoroute { pub fn navmesh(&self) -> Option<&Navmesh> { self.route.as_ref().map(|route| route.navmesh()) } + + pub fn trace(&self) -> Option<&Trace> { + self.route.as_ref().map(|route| route.trace()) + } } impl GetMaybeNavmesh for Autoroute { @@ -91,3 +98,9 @@ impl GetMaybeNavmesh for Autoroute { self.route.as_ref().map(|route| route.navmesh()) } } + +impl GetMaybeTrace for Autoroute { + fn maybe_trace(&self) -> Option<&Trace> { + self.route.as_ref().map(|route| route.trace()) + } +} diff --git a/src/autorouter/invoker.rs b/src/autorouter/invoker.rs index b6a38fa..985832e 100644 --- a/src/autorouter/invoker.rs +++ b/src/autorouter/invoker.rs @@ -13,7 +13,7 @@ use crate::{ }, board::mesadata::MesadataTrait, layout::via::ViaWeight, - router::navmesh::Navmesh, + router::{navmesh::Navmesh, trace::Trace}, }; #[enum_dispatch] @@ -21,6 +21,11 @@ pub trait GetMaybeNavmesh { fn maybe_navmesh(&self) -> Option<&Navmesh>; } +#[enum_dispatch] +pub trait GetMaybeTrace { + fn maybe_trace(&self) -> Option<&Trace>; +} + #[derive(Error, Debug, Clone)] pub enum InvokerError { #[error(transparent)] @@ -41,7 +46,7 @@ pub enum Command { PlaceVia(ViaWeight), } -#[enum_dispatch(GetMaybeNavmesh)] +#[enum_dispatch(GetMaybeNavmesh, GetMaybeTrace)] pub enum Execute { Autoroute(Autoroute), PlaceVia(PlaceVia), @@ -118,6 +123,12 @@ impl GetMaybeNavmesh for ExecuteWithStatus { } } +impl GetMaybeTrace for ExecuteWithStatus { + fn maybe_trace(&self) -> Option<&Trace> { + self.execute.maybe_trace() + } +} + pub struct Invoker { autorouter: Autorouter, history: History, diff --git a/src/autorouter/place_via.rs b/src/autorouter/place_via.rs index 5307502..43db0ea 100644 --- a/src/autorouter/place_via.rs +++ b/src/autorouter/place_via.rs @@ -1,8 +1,11 @@ use crate::{ - autorouter::{invoker::GetMaybeNavmesh, Autorouter, AutorouterError}, + autorouter::{ + invoker::{GetMaybeNavmesh, GetMaybeTrace}, + Autorouter, AutorouterError, + }, board::mesadata::MesadataTrait, layout::via::ViaWeight, - router::navmesh::Navmesh, + router::{navmesh::Navmesh, trace::Trace}, }; #[derive(Debug)] @@ -28,3 +31,9 @@ impl GetMaybeNavmesh for PlaceVia { None } } + +impl GetMaybeTrace for PlaceVia { + fn maybe_trace(&self) -> Option<&Trace> { + None + } +} diff --git a/src/bin/topola-egui/viewport.rs b/src/bin/topola-egui/viewport.rs index 5c403f2..bdc51af 100644 --- a/src/bin/topola-egui/viewport.rs +++ b/src/bin/topola-egui/viewport.rs @@ -1,7 +1,10 @@ use geo::point; -use petgraph::visit::{EdgeRef, IntoEdgeReferences}; +use petgraph::{ + data::DataMap, + visit::{EdgeRef, IntoEdgeReferences}, +}; use topola::{ - autorouter::invoker::{Command, ExecuteWithStatus, GetMaybeNavmesh, Invoker}, + autorouter::invoker::{Command, ExecuteWithStatus, GetMaybeNavmesh, GetMaybeTrace, Invoker}, board::mesadata::MesadataTrait, drawing::{ graph::{MakePrimitive, PrimitiveIndex}, @@ -154,26 +157,26 @@ impl Viewport { if top.show_navmesh { if let Some(execute) = maybe_execute { if let Some(navmesh) = execute.maybe_navmesh() { - for edge in navmesh.graph().edge_references() { - let from = PrimitiveIndex::from(navmesh.graph().node_weight(edge.source()).unwrap().node) + for edge in navmesh.edge_references() { + let from = PrimitiveIndex::from(navmesh.node_weight(edge.source()).unwrap().node) .primitive(board.layout().drawing()) .shape() .center(); - let to = PrimitiveIndex::from(navmesh.graph().node_weight(edge.target()).unwrap().node) + let to = PrimitiveIndex::from(navmesh.node_weight(edge.target()).unwrap().node) .primitive(board.layout().drawing()) .shape() .center(); let stroke = 'blk: { - /*if let (Some(source_pos), Some(target_pos)) = ( - shared_data - .path + if let (Some(source_pos), Some(target_pos)) = ( + execute.maybe_trace().map(|trace| + trace.path .iter() - .position(|node| *node == navmesh.graph().node_weight(edge.source()).unwrap().node), - shared_data - .path + .position(|node| *node == edge.source())).flatten(), + execute.maybe_trace().map(|trace| + trace.path .iter() - .position(|node| *node == navmesh.graph().node_weight(edge.target()).unwrap().node), + .position(|node| *node == edge.target())).flatten(), ) { if target_pos == source_pos + 1 || source_pos == target_pos + 1 @@ -183,7 +186,7 @@ impl Viewport { egui::Color32::from_rgb(250, 250, 0), ); } - }*/ + } egui::Stroke::new(1.0, egui::Color32::from_rgb(125, 125, 125)) }; @@ -200,17 +203,17 @@ impl Viewport { if let Some(execute) = maybe_execute { if let Some(navmesh) = execute.maybe_navmesh() { - if let (from, to) = (navmesh.source(), navmesh.target()) { + if let (origin, destination) = (navmesh.origin(), navmesh.destination()) { painter.paint_dot( Circle { - pos: board.layout().drawing().primitive(from).shape().center(), + pos: board.layout().drawing().primitive(origin).shape().center(), r: 60.0, }, egui::Color32::from_rgb(255, 255, 100), ); painter.paint_dot( Circle { - pos: board.layout().drawing().primitive(to).shape().center(), + pos: board.layout().drawing().primitive(destination).shape().center(), r: 60.0, }, egui::Color32::from_rgb(255, 255, 100), diff --git a/src/router/navmesh.rs b/src/router/navmesh.rs index ef057f4..41c5fc0 100644 --- a/src/router/navmesh.rs +++ b/src/router/navmesh.rs @@ -106,10 +106,10 @@ pub enum NavmeshError { #[derive(Debug, Clone)] pub struct Navmesh { graph: UnGraph, - source: FixedDotIndex, - source_navvertex: NavvertexIndex, - target: FixedDotIndex, - target_navvertex: NavvertexIndex, + origin: FixedDotIndex, + origin_navvertex: NavvertexIndex, + destination: FixedDotIndex, + destination_navvertex: NavvertexIndex, } impl Navmesh { @@ -204,10 +204,10 @@ impl Navmesh { Ok(Self { graph, - source, - source_navvertex: NavvertexIndex(source_navvertex.unwrap()), - target, - target_navvertex: NavvertexIndex(target_navvertex.unwrap()), + origin: source, + origin_navvertex: NavvertexIndex(source_navvertex.unwrap()), + destination: target, + destination_navvertex: NavvertexIndex(target_navvertex.unwrap()), }) } @@ -215,20 +215,20 @@ impl Navmesh { &self.graph } - pub fn source(&self) -> FixedDotIndex { - self.source + pub fn origin(&self) -> FixedDotIndex { + self.origin } - pub fn source_navvertex(&self) -> NavvertexIndex { - self.source_navvertex + pub fn origin_navvertex(&self) -> NavvertexIndex { + self.origin_navvertex } - pub fn target(&self) -> FixedDotIndex { - self.target + pub fn destination(&self) -> FixedDotIndex { + self.destination } - pub fn target_navvertex(&self) -> NavvertexIndex { - self.target_navvertex + pub fn destination_navvertex(&self) -> NavvertexIndex { + self.destination_navvertex } } diff --git a/src/router/route.rs b/src/router/route.rs index 208e225..d32e44a 100644 --- a/src/router/route.rs +++ b/src/router/route.rs @@ -53,9 +53,9 @@ impl Route { navmesh: Navmesh, width: f64, ) -> Self { - let source = navmesh.source(); - let source_navvertex = navmesh.source_navvertex(); - let target = navmesh.target(); + let source = navmesh.origin(); + let source_navvertex = navmesh.origin_navvertex(); + let target = navmesh.destination(); let mut tracer = Tracer::new(router.layout_mut()); let mut trace = tracer.start(source, source_navvertex, width); @@ -71,7 +71,7 @@ impl Route { router: &mut Router, ) -> Result { let tracer = Tracer::new(router.layout_mut()); - let target = self.astar.graph.target(); + let target = self.astar.graph.destination(); let mut strategy = RouterAstarStrategy::new(tracer, &mut self.trace, target); match self.astar.step(&mut strategy)? { @@ -83,4 +83,8 @@ impl Route { pub fn navmesh(&self) -> &Navmesh { &self.astar.graph } + + pub fn trace(&self) -> &Trace { + &self.trace + } }