mirror of https://codeberg.org/topola/topola.git
594 lines
24 KiB
Rust
594 lines
24 KiB
Rust
use futures::executor;
|
|
use geo::point;
|
|
use petgraph::visit::{EdgeRef, IntoEdgeReferences};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{
|
|
fs::File,
|
|
future::Future,
|
|
sync::{
|
|
mpsc::{channel, Receiver, Sender},
|
|
Arc, Mutex,
|
|
},
|
|
};
|
|
|
|
use topola::{
|
|
autorouter::{
|
|
invoker::{Command, Execute, Invoker, InvokerStatus},
|
|
Autorouter,
|
|
},
|
|
drawing::{
|
|
dot::FixedDotIndex,
|
|
graph::{MakePrimitive, PrimitiveIndex},
|
|
primitive::MakePrimitiveShape,
|
|
rules::RulesTrait,
|
|
Drawing, Infringement, LayoutException,
|
|
},
|
|
dsn::{design::DsnDesign, mesadata::DsnMesadata},
|
|
geometry::{
|
|
compound::CompoundManagerTrait,
|
|
primitive::{BendShape, DotShape, PrimitiveShape, PrimitiveShapeTrait, SegShape},
|
|
shape::ShapeTrait,
|
|
GenericNode,
|
|
},
|
|
layout::{via::ViaWeight, zone::MakePolyShape, Layout},
|
|
math::Circle,
|
|
router::{
|
|
draw::DrawException,
|
|
navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex},
|
|
tracer::{Trace, Tracer},
|
|
EmptyRouterObserver, RouterObserverTrait,
|
|
},
|
|
};
|
|
|
|
use crate::{layers::Layers, overlay::Overlay, painter::Painter};
|
|
|
|
#[derive(Debug, Default)]
|
|
struct SharedData {
|
|
pub from: Option<FixedDotIndex>,
|
|
pub to: Option<FixedDotIndex>,
|
|
pub navmesh: Option<Navmesh>,
|
|
pub path: Vec<NavvertexIndex>,
|
|
pub ghosts: Vec<PrimitiveShape>,
|
|
pub highlighteds: Vec<PrimitiveIndex>,
|
|
}
|
|
|
|
/// Deserialize/Serialize is needed to persist app state between restarts.
|
|
#[derive(Serialize, Deserialize)]
|
|
#[serde(default)]
|
|
pub struct App {
|
|
#[serde(skip)]
|
|
overlay: Option<Overlay>,
|
|
|
|
#[serde(skip)]
|
|
invoker: Option<Arc<Mutex<Invoker<DsnMesadata>>>>,
|
|
|
|
#[serde(skip)]
|
|
shared_data: Arc<Mutex<SharedData>>,
|
|
|
|
#[serde(skip)]
|
|
text_channel: (Sender<String>, Receiver<String>),
|
|
|
|
#[serde(skip)]
|
|
from_rect: egui::emath::Rect,
|
|
|
|
#[serde(skip)]
|
|
is_placing_via: bool,
|
|
|
|
#[serde(skip)]
|
|
show_ratsnest: bool,
|
|
|
|
#[serde(skip)]
|
|
layers: Option<Layers>,
|
|
}
|
|
|
|
impl Default for App {
|
|
fn default() -> Self {
|
|
Self {
|
|
overlay: None,
|
|
invoker: None,
|
|
shared_data: Default::default(),
|
|
text_channel: channel(),
|
|
from_rect: egui::Rect::from_x_y_ranges(0.0..=1000000.0, 0.0..=500000.0),
|
|
is_placing_via: false,
|
|
show_ratsnest: true,
|
|
layers: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
/// Called once on start.
|
|
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
|
|
// Load previous app state if one exists.
|
|
if let Some(storage) = cc.storage {
|
|
return eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
|
|
}
|
|
|
|
Default::default()
|
|
}
|
|
}
|
|
|
|
struct DebugRouterObserver {
|
|
shared_data: Arc<Mutex<SharedData>>,
|
|
}
|
|
|
|
impl<R: RulesTrait + std::fmt::Debug> RouterObserverTrait<R> for DebugRouterObserver {
|
|
fn on_rework(&mut self, tracer: &Tracer<R>, trace: &Trace) {
|
|
//dbg!(_tracer, _trace);
|
|
let mut shared_data = self.shared_data.lock().unwrap();
|
|
shared_data.path = trace.path.clone();
|
|
shared_data.ghosts = vec![];
|
|
shared_data.highlighteds = vec![];
|
|
std::thread::sleep_ms(500);
|
|
}
|
|
fn before_probe(&mut self, tracer: &Tracer<R>, trace: &Trace, edge: NavmeshEdgeReference) {
|
|
//dbg!(_tracer, _trace, _edge);
|
|
let mut shared_data = self.shared_data.lock().unwrap();
|
|
shared_data.path = trace.path.clone();
|
|
shared_data.path.push(edge.target());
|
|
shared_data.ghosts = vec![];
|
|
shared_data.highlighteds = vec![];
|
|
std::thread::sleep_ms(100);
|
|
}
|
|
fn on_probe(
|
|
&mut self,
|
|
tracer: &Tracer<R>,
|
|
trace: &Trace,
|
|
edge: NavmeshEdgeReference,
|
|
result: Result<(), DrawException>,
|
|
) {
|
|
//dbg!(_tracer, _trace, _edge, _result);
|
|
let mut shared_data = self.shared_data.lock().unwrap();
|
|
let (ghosts, highlighteds, delay) = match result {
|
|
Err(DrawException::CannotWrapAround(
|
|
..,
|
|
LayoutException::Infringement(Infringement(shape1, infringee1)),
|
|
LayoutException::Infringement(Infringement(shape2, infringee2)),
|
|
)) => (vec![shape1, shape2], vec![infringee1, infringee2], 1500),
|
|
_ => (vec![], vec![], 300),
|
|
};
|
|
|
|
shared_data.path = trace.path.clone();
|
|
shared_data.ghosts = ghosts;
|
|
shared_data.highlighteds = highlighteds;
|
|
std::thread::sleep_ms(delay);
|
|
}
|
|
fn on_estimate(&mut self, _tracer: &Tracer<R>, _vertex: NavvertexIndex) {
|
|
//dbg!(_tracer, _vertex);
|
|
}
|
|
}
|
|
|
|
impl eframe::App for App {
|
|
/// Called to save state before shutdown.
|
|
fn save(&mut self, storage: &mut dyn eframe::Storage) {
|
|
eframe::set_value(storage, eframe::APP_KEY, self);
|
|
}
|
|
|
|
/// Called each time the UI has to be repainted.
|
|
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
|
let mut has_acted = false;
|
|
|
|
if cfg!(target_arch = "wasm32") {
|
|
if let Ok(file_contents) = self.text_channel.1.try_recv() {
|
|
let design = DsnDesign::load_from_string(file_contents).unwrap();
|
|
let board = design.make_board();
|
|
self.overlay = Some(Overlay::new(&board).unwrap());
|
|
self.layers = Some(Layers::new(&board));
|
|
self.invoker = Some(Arc::new(Mutex::new(Invoker::new(
|
|
Autorouter::new(board).unwrap(),
|
|
))));
|
|
}
|
|
} else {
|
|
if let Ok(path) = self.text_channel.1.try_recv() {
|
|
let design = DsnDesign::load_from_file(&path).unwrap();
|
|
let board = design.make_board();
|
|
self.overlay = Some(Overlay::new(&board).unwrap());
|
|
self.layers = Some(Layers::new(&board));
|
|
self.invoker = Some(Arc::new(Mutex::new(Invoker::new(
|
|
Autorouter::new(board).unwrap(),
|
|
))));
|
|
}
|
|
}
|
|
|
|
egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
|
|
egui::menu::bar(ui, |ui| {
|
|
ui.menu_button("File", |ui| {
|
|
if ui.button("Open").clicked() {
|
|
// `Context` is cheap to clone as it's wrapped in an `Arc`.
|
|
let ctx = ui.ctx().clone();
|
|
// NOTE: On Linux, this requires Zenity to be installed on your system.
|
|
let sender = self.text_channel.0.clone();
|
|
let task = rfd::AsyncFileDialog::new().pick_file();
|
|
|
|
execute(async move {
|
|
if let Some(file_handle) = task.await {
|
|
sender.send(channel_text(file_handle).await);
|
|
ctx.request_repaint();
|
|
}
|
|
});
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
if ui.button("Load history").clicked() {
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
let ctx = ui.ctx().clone();
|
|
let task = rfd::AsyncFileDialog::new().pick_file();
|
|
|
|
execute(async move {
|
|
if let Some(file_handle) = task.await {
|
|
let path = file_handle.path();
|
|
let mut invoker = invoker_arc_mutex.lock().unwrap();
|
|
let mut file = File::open(path).unwrap();
|
|
invoker.replay(serde_json::from_reader(file).unwrap());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if ui.button("Save history").clicked() {
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
let ctx = ui.ctx().clone();
|
|
let task = rfd::AsyncFileDialog::new().save_file();
|
|
|
|
execute(async move {
|
|
if let Some(file_handle) = task.await {
|
|
let path = file_handle.path();
|
|
let mut invoker = invoker_arc_mutex.lock().unwrap();
|
|
let mut file = File::create(path).unwrap();
|
|
serde_json::to_writer_pretty(file, invoker.history());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
// "Quit" button wouldn't work on a Web page.
|
|
if !cfg!(target_arch = "wasm32") {
|
|
if ui.button("Quit").clicked() {
|
|
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
|
|
}
|
|
}
|
|
});
|
|
|
|
ui.separator();
|
|
|
|
if ui.button("Autoroute").clicked() {
|
|
if let (Some(invoker_arc_mutex), Some(overlay)) = (&self.invoker, &self.overlay)
|
|
{
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
let shared_data_arc_mutex = self.shared_data.clone();
|
|
let selection = overlay.selection().clone();
|
|
|
|
execute(async move {
|
|
let mut invoker = invoker_arc_mutex.lock().unwrap();
|
|
let mut execute = invoker.execute_walk(Command::Autoroute(selection));
|
|
|
|
if let Execute::Autoroute(ref mut autoroute) = execute {
|
|
let from = autoroute.navmesh().as_ref().unwrap().source();
|
|
let to = autoroute.navmesh().as_ref().unwrap().target();
|
|
|
|
{
|
|
let mut shared_data = shared_data_arc_mutex.lock().unwrap();
|
|
shared_data.from = Some(from);
|
|
shared_data.to = Some(to);
|
|
shared_data.navmesh = autoroute.navmesh().clone();
|
|
}
|
|
}
|
|
|
|
let _ = loop {
|
|
let status = match execute.step(
|
|
&mut invoker,
|
|
&mut DebugRouterObserver {
|
|
shared_data: shared_data_arc_mutex.clone(),
|
|
},
|
|
) {
|
|
Ok(status) => status,
|
|
Err(err) => return,
|
|
};
|
|
|
|
if let Execute::Autoroute(ref mut autoroute) = execute {
|
|
shared_data_arc_mutex.lock().unwrap().navmesh =
|
|
autoroute.navmesh().clone();
|
|
}
|
|
|
|
if let InvokerStatus::Finished = status {
|
|
break;
|
|
}
|
|
};
|
|
});
|
|
}
|
|
}
|
|
|
|
if ui
|
|
.toggle_value(&mut self.is_placing_via, "Place Via")
|
|
.clicked()
|
|
{
|
|
has_acted = true;
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
if ui.button("Undo").clicked()
|
|
|| ctx.input_mut(|i| i.consume_key(egui::Modifiers::CTRL, egui::Key::Z))
|
|
{
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
execute(async move {
|
|
invoker_arc_mutex.lock().unwrap().undo();
|
|
});
|
|
}
|
|
}
|
|
|
|
if ui.button("Redo").clicked()
|
|
|| ctx.input_mut(|i| i.consume_key(egui::Modifiers::CTRL, egui::Key::Y))
|
|
{
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
execute(async move {
|
|
invoker_arc_mutex.lock().unwrap().redo();
|
|
});
|
|
}
|
|
}
|
|
|
|
ui.separator();
|
|
|
|
ui.toggle_value(&mut self.show_ratsnest, "Show Ratsnest");
|
|
|
|
ui.separator();
|
|
|
|
egui::widgets::global_dark_light_mode_buttons(ui);
|
|
});
|
|
});
|
|
|
|
if let Some(ref mut layers) = self.layers {
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
layers.update(ctx, invoker_arc_mutex.lock().unwrap().autorouter().board());
|
|
}
|
|
}
|
|
|
|
egui::CentralPanel::default().show(ctx, |ui| {
|
|
egui::Frame::canvas(ui.style()).show(ui, |ui| {
|
|
ui.ctx().request_repaint();
|
|
|
|
let desired_size = ui.available_width() * egui::vec2(1.0, 0.5);
|
|
let (_id, viewport_rect) = ui.allocate_space(desired_size);
|
|
|
|
let old_transform =
|
|
egui::emath::RectTransform::from_to(self.from_rect, viewport_rect);
|
|
let latest_pos = old_transform
|
|
.inverse()
|
|
.transform_pos(ctx.input(|i| i.pointer.latest_pos().unwrap_or_default()));
|
|
|
|
let old_scale = old_transform.scale().x;
|
|
self.from_rect = self.from_rect / ctx.input(|i| i.zoom_delta());
|
|
|
|
let new_scale = egui::emath::RectTransform::from_to(self.from_rect, viewport_rect)
|
|
.scale()
|
|
.x;
|
|
|
|
self.from_rect = self.from_rect.translate(
|
|
ctx.input(|i| latest_pos.to_vec2() * (new_scale - old_scale) / new_scale),
|
|
);
|
|
|
|
self.from_rect = self
|
|
.from_rect
|
|
.translate(ctx.input(|i| -i.raw_scroll_delta / new_scale));
|
|
|
|
let transform = egui::emath::RectTransform::from_to(self.from_rect, viewport_rect);
|
|
let mut painter = Painter::new(ui, transform);
|
|
|
|
if let Some(invoker_arc_mutex) = &self.invoker {
|
|
if ctx.input(|i| i.pointer.any_click()) {
|
|
if !has_acted {
|
|
if self.is_placing_via {
|
|
let invoker_arc_mutex = invoker_arc_mutex.clone();
|
|
|
|
execute(async move {
|
|
let mut invoker = invoker_arc_mutex.lock().unwrap();
|
|
invoker.execute(
|
|
Command::PlaceVia(ViaWeight {
|
|
from_layer: 0,
|
|
to_layer: 0,
|
|
circle: Circle {
|
|
pos: point! {x: latest_pos.x as f64, y: -latest_pos.y as f64},
|
|
r: 10000.0,
|
|
},
|
|
maybe_net: Some(1234),
|
|
}),
|
|
&mut EmptyRouterObserver,
|
|
);
|
|
});
|
|
} else if let Some(overlay) = &mut self.overlay {
|
|
let invoker = invoker_arc_mutex.lock().unwrap();
|
|
overlay.click(
|
|
invoker.autorouter().board(),
|
|
point! {x: latest_pos.x as f64, y: -latest_pos.y as f64},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if let (invoker, shared_data, Some(overlay)) = (
|
|
&invoker_arc_mutex.lock().unwrap(),
|
|
self.shared_data.lock().unwrap(),
|
|
&mut self.overlay,
|
|
) {
|
|
let board = invoker.autorouter().board();
|
|
|
|
for primitive in board.layout().drawing().layer_primitive_nodes(1) {
|
|
let shape = primitive.primitive(board.layout().drawing()).shape();
|
|
|
|
let color = if shared_data.highlighteds.contains(&primitive)
|
|
|| overlay
|
|
.selection()
|
|
.contains_node(board, GenericNode::Primitive(primitive))
|
|
{
|
|
egui::Color32::from_rgb(100, 100, 255)
|
|
} else {
|
|
egui::Color32::from_rgb(52, 52, 200)
|
|
};
|
|
painter.paint_primitive(&shape, color);
|
|
}
|
|
|
|
for zone in board.layout().layer_zone_nodes(1) {
|
|
let color = if overlay
|
|
.selection()
|
|
.contains_node(board, GenericNode::Compound(zone.into()))
|
|
{
|
|
egui::Color32::from_rgb(100, 100, 255)
|
|
} else {
|
|
egui::Color32::from_rgb(52, 52, 200)
|
|
};
|
|
painter.paint_polygon(&board.layout().zone(zone).shape().polygon, color)
|
|
}
|
|
|
|
for primitive in board.layout().drawing().layer_primitive_nodes(0) {
|
|
let shape = primitive.primitive(board.layout().drawing()).shape();
|
|
|
|
let color = if shared_data.highlighteds.contains(&primitive)
|
|
|| overlay
|
|
.selection()
|
|
.contains_node(board, GenericNode::Primitive(primitive))
|
|
{
|
|
egui::Color32::from_rgb(255, 100, 100)
|
|
} else {
|
|
egui::Color32::from_rgb(200, 52, 52)
|
|
};
|
|
painter.paint_primitive(&shape, color);
|
|
}
|
|
|
|
for zone in board.layout().layer_zone_nodes(0) {
|
|
let color = if overlay
|
|
.selection()
|
|
.contains_node(board, GenericNode::Compound(zone.into()))
|
|
{
|
|
egui::Color32::from_rgb(255, 100, 100)
|
|
} else {
|
|
egui::Color32::from_rgb(200, 52, 52)
|
|
};
|
|
painter.paint_polygon(&board.layout().zone(zone).shape().polygon, color)
|
|
}
|
|
|
|
if self.show_ratsnest {
|
|
for edge in overlay.ratsnest().graph().edge_references() {
|
|
let from = overlay
|
|
.ratsnest()
|
|
.graph()
|
|
.node_weight(edge.source())
|
|
.unwrap()
|
|
.pos;
|
|
let to = overlay
|
|
.ratsnest()
|
|
.graph()
|
|
.node_weight(edge.target())
|
|
.unwrap()
|
|
.pos;
|
|
|
|
painter.paint_edge(
|
|
from,
|
|
to,
|
|
egui::Stroke::new(1.0, egui::Color32::from_rgb(90, 90, 200)),
|
|
);
|
|
}
|
|
}
|
|
|
|
if let Some(navmesh) = &shared_data.navmesh {
|
|
for edge in navmesh.edge_references() {
|
|
let from = edge
|
|
.source()
|
|
.primitive(board.layout().drawing())
|
|
.shape()
|
|
.center();
|
|
let to = edge
|
|
.target()
|
|
.primitive(board.layout().drawing())
|
|
.shape()
|
|
.center();
|
|
|
|
let stroke = 'blk: {
|
|
if let (Some(source_pos), Some(target_pos)) = (
|
|
shared_data
|
|
.path
|
|
.iter()
|
|
.position(|node| *node == edge.source()),
|
|
shared_data
|
|
.path
|
|
.iter()
|
|
.position(|node| *node == edge.target()),
|
|
) {
|
|
if target_pos == source_pos + 1
|
|
|| source_pos == target_pos + 1
|
|
{
|
|
break 'blk egui::Stroke::new(
|
|
5.0,
|
|
egui::Color32::from_rgb(250, 250, 0),
|
|
);
|
|
}
|
|
}
|
|
|
|
egui::Stroke::new(1.0, egui::Color32::from_rgb(125, 125, 125))
|
|
};
|
|
|
|
painter.paint_edge(from, to, stroke);
|
|
}
|
|
}
|
|
|
|
for ghost in shared_data.ghosts.iter() {
|
|
painter.paint_primitive(&ghost, egui::Color32::from_rgb(75, 75, 150));
|
|
}
|
|
|
|
if let (Some(from), Some(to)) = (shared_data.from, shared_data.to) {
|
|
painter.paint_dot(
|
|
Circle {
|
|
pos: board.layout().drawing().primitive(from).shape().center(),
|
|
r: 20.0,
|
|
},
|
|
egui::Color32::from_rgb(255, 255, 100),
|
|
);
|
|
painter.paint_dot(
|
|
Circle {
|
|
pos: board.layout().drawing().primitive(to).shape().center(),
|
|
r: 20.0,
|
|
},
|
|
egui::Color32::from_rgb(255, 255, 100),
|
|
);
|
|
}
|
|
|
|
//unreachable!();
|
|
}
|
|
}
|
|
})
|
|
});
|
|
|
|
if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
|
|
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn execute<F: Future<Output = ()> + Send + 'static>(f: F) {
|
|
std::thread::spawn(move || futures::executor::block_on(f));
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
fn execute<F: Future<Output = ()> + 'static>(f: F) {
|
|
wasm_bindgen_futures::spawn_local(f);
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
async fn channel_text(file_handle: rfd::FileHandle) -> String {
|
|
file_handle.path().to_str().unwrap().to_string()
|
|
}
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
async fn channel_text(file_handle: rfd::FileHandle) -> String {
|
|
std::str::from_utf8(&file_handle.read().await)
|
|
.unwrap()
|
|
.to_string()
|
|
}
|