a770fa5a5e5f
viewport.rs
//! Snap queries through the same rectangular layout viewports that the renderer displays.
use cadcraft_doc::{Drawing, EntityKind, Handle, Space, Viewport};
use cadcraft_geom::{Bounds2, Vec2};
use serde::Serialize;
use super::{Deferred, SnapCurve, SnapHit};
/// A model-space snap seen through a layout viewport. Commands still receive paper coordinates;
/// DIST can use these model coordinates when both picks came through the same viewport.
#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
pub struct ViewportPoint {
pub viewport: Handle,
pub point: Vec2,
/// Paper units per model unit at the time of the pick.
pub scale: f64,
}
pub(super) struct Projection<'a> {
pub handle: Handle,
pub viewport: &'a Viewport,
pub scale: f64,
pub model_clip: Bounds2,
paper_clip: Bounds2,
}
impl<'a> Projection<'a> {
fn new(handle: Handle, viewport: &'a Viewport) -> Option<Self> {
let positive = |v: f64| v.is_finite() && v > 0.0;
let center = viewport.center.xy();
if viewport.id == 1
|| !(center.is_finite() && viewport.view_center.is_finite())
|| ![viewport.width, viewport.height, viewport.view_height].into_iter().all(positive)
{
return None;
}
let scale = viewport.height / viewport.view_height;
if !positive(scale) || !positive(1.0 / scale) {
return None;
}
let half = Vec2::new(viewport.width / 2.0, viewport.height / 2.0);
let paper_clip = Bounds2::new(center - half, center + half);
// The model box the viewport shows (turned, with a view twist).
let model_clip = Bounds2::from_points(paper_clip.corners().map(|p| viewport.paper_to_model(p)));
if ![paper_clip.min, paper_clip.max, model_clip.min, model_clip.max].into_iter().all(Vec2::is_finite) {
return None;
}
Some(Self { handle, viewport, scale, model_clip, paper_clip })
}
pub fn to_model(&self, point: Vec2) -> Vec2 {
self.viewport.paper_to_model(point)
}
fn to_paper(&self, point: Vec2) -> Vec2 {
self.viewport.model_to_paper(point)
}
pub fn hit(&self, mut hit: SnapHit) -> Option<SnapHit> {
let model_point = hit.point;
hit.point = self.to_paper(model_point);
if !hit.point.is_finite() || !self.paper_clip.contains(hit.point) {
return None;
}
hit.viewport = Some(ViewportPoint { viewport: self.handle, point: model_point, scale: self.scale });
if let Some(d) = hit.deferred {
let curve = match d.curve {
SnapCurve::Circle { center, radius } => {
let (center, radius) = (self.to_paper(center), radius * self.scale);
if !(center.is_finite() && radius.is_finite() && radius > 0.0) {
return None;
}
SnapCurve::Circle { center, radius }
}
SnapCurve::Arc { center, radius, start, end } => {
let (center, radius) = (self.to_paper(center), radius * self.scale);
if !(center.is_finite() && radius.is_finite() && radius > 0.0) {
return None;
}
// The arc turns on the sheet with the viewport's twist.
let twist = self.viewport.view_twist();
SnapCurve::Arc { center, radius, start: start + twist, end: end + twist }
}
SnapCurve::Line { a, b } => {
let (a, b) = (self.to_paper(a), self.to_paper(b));
if !(a.is_finite() && b.is_finite()) {
return None;
}
SnapCurve::Line { a, b }
}
};
hit.deferred = Some(Deferred { mode: d.mode, curve, at: hit.point });
}
Some(hit)
}
}
/// Bound layout work like the renderer. An off viewport layer hides its border, while a frozen
/// viewport layer (or an invisible viewport entity) also hides its model contents.
pub(super) fn near<'a>(d: &'a Drawing, space: &Space, cursor: Vec2, aperture: f64) -> Vec<Projection<'a>> {
if !matches!(space, Space::Paper(_)) {
return Vec::new();
}
let Some(store) = d.space(space) else { return Vec::new() };
let probe = Bounds2::new(cursor, cursor).expand(aperture);
store
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Viewport(vp) => Some((e, vp)),
_ => None,
})
.take(256)
.filter(|(e, _)| e.common.visible && !d.layer(&e.common.layer).is_some_and(|l| l.frozen))
.filter_map(|(e, vp)| Projection::new(e.handle, vp))
.filter(|p| p.paper_clip.intersects(&probe))
.collect()
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.