use super::{
frame::FacetFrame,
handles::{HandleKind, HandleLayout},
projection::ScreenPoint,
};
use glam::Vec3;
use indicatrix_cut_core::ConstraintTier;
use indicatrix_solid::diagram2d::{DiagramLayout, PanelKind, PanelLayout, project_point};
pub const MIN_FORESHORTENING: f32 = 0.15;
pub const EDGE_ON_MAX_NORMAL_Z: f32 = 0.2;
const ANGLE_TIP_FRACTION: f32 = 0.32;
const DEPTH_TIP_FRACTION: f32 = 0.62;
const INDEX_TIP_FRACTION: f32 = 0.32;
const MIN_TIP_PX: f32 = 26.0;
const MIN_TIP_GAP_PX: f32 = 28.0;
const MIN_WHEEL_RADIUS_PX: f32 = 40.0;
const MIN_ROTATION_RADIUS_PX: f32 = 4.0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct HandleAvailability {
pub angle: bool,
pub depth: bool,
pub index: bool,
}
impl HandleAvailability {
#[must_use]
pub const fn offers(self, kind: HandleKind) -> bool {
match kind {
HandleKind::Angle => self.angle,
HandleKind::Depth => self.depth,
HandleKind::Index => self.index,
}
}
#[must_use]
pub const fn any(self) -> bool {
self.angle || self.depth || self.index
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PanelHandles {
pub panel: PanelKind,
pub layout: HandleLayout,
pub available: HandleAvailability,
pub rotation: Option<IndexRotation>,
}
#[must_use]
pub fn facet_frame(
tier: &ConstraintTier,
index_on_gear: f64,
layout: &DiagramLayout,
centroid: Vec3,
) -> FacetFrame {
FacetFrame::from_tier_with_reference(
tier,
index_on_gear,
layout.gear_reference_angle,
layout.gear_teeth,
centroid,
)
}
fn length(v: (f32, f32)) -> f32 {
v.0.hypot(v.1)
}
fn unit(v: (f32, f32), fallback: (f32, f32)) -> (f32, f32) {
let len = length(v);
if len > 1e-6 {
(v.0 / len, v.1 / len)
} else {
fallback
}
}
fn screen_vector(panel: &PanelLayout, centroid: Vec3, v: Vec3) -> (f32, f32) {
let from = project_point(centroid.as_dvec3(), panel);
let to = project_point((centroid + v).as_dvec3(), panel);
(to.0 - from.0, to.1 - from.1)
}
fn panel_carries(panel: PanelKind, normal: Vec3) -> bool {
match panel {
PanelKind::Crown | PanelKind::Pavilion => panel.shows(normal),
PanelKind::Profile => normal.z.abs() <= EDGE_ON_MAX_NORMAL_Z,
}
}
const fn tip_at(anchor: ScreenPoint, dir: (f32, f32), distance: f32, offered: bool) -> ScreenPoint {
if offered {
ScreenPoint::new(
dir.0.mul_add(distance, anchor.x),
dir.1.mul_add(distance, anchor.y),
)
} else {
ScreenPoint::new(f32::NAN, f32::NAN)
}
}
#[must_use]
pub fn panel_handles(frame: &FacetFrame, panel: &PanelLayout) -> Option<PanelHandles> {
if !panel_carries(panel.kind, frame.normal) {
return None;
}
let centroid = frame.centroid;
let scale = panel.scale;
if !scale.is_finite() || scale <= 0.0 {
return None;
}
let anchor_px = project_point(centroid.as_dvec3(), panel);
let anchor = ScreenPoint::new(anchor_px.0, anchor_px.1);
let angle_vec = screen_vector(panel, centroid, frame.tangent_theta());
let depth_vec = screen_vector(panel, centroid, frame.normal);
let index_vec = screen_vector(panel, centroid, frame.tangent_phi());
let on_wheel = matches!(panel.kind, PanelKind::Crown | PanelKind::Pavilion);
let available = HandleAvailability {
angle: length(angle_vec) / scale >= MIN_FORESHORTENING,
depth: length(depth_vec) / scale >= MIN_FORESHORTENING,
index: on_wheel && !frame.is_indexless(),
};
let wheel = if panel.wheel_radius_px.is_finite() {
panel.wheel_radius_px.max(MIN_WHEEL_RADIUS_PX)
} else {
MIN_WHEEL_RADIUS_PX
};
let angle_len = (ANGLE_TIP_FRACTION * wheel).max(MIN_TIP_PX);
let index_len = (INDEX_TIP_FRACTION * wheel).max(MIN_TIP_PX);
let depth_len = if on_wheel {
(DEPTH_TIP_FRACTION * wheel).max(angle_len + MIN_TIP_GAP_PX)
} else {
angle_len
};
let angle_dir = unit(angle_vec, (0.0, -1.0));
let depth_dir = unit(depth_vec, (1.0, 0.0));
let index_dir = unit(index_vec, (1.0, 0.0));
let radius = centroid.x.hypot(centroid.z).max(1e-3);
let tooth_arc = radius * std::f32::consts::TAU / frame.gear_teeth.max(1) as f32;
let layout = HandleLayout {
anchor,
angle_tip: tip_at(anchor, angle_dir, angle_len, available.angle),
depth_tip: tip_at(anchor, depth_dir, depth_len, available.depth),
index_tip: tip_at(anchor, index_dir, index_len, available.index),
angle_dir,
depth_dir,
index_dir,
pixels_per_degree: length(angle_vec).to_radians(),
pixels_per_mast_unit: length(depth_vec),
pixels_per_tooth: length(index_vec) * tooth_arc,
};
let rotation = on_wheel.then_some(IndexRotation::new(
ScreenPoint::new(panel.center_x, panel.center_y),
panel.kind == PanelKind::Pavilion,
frame.gear_teeth,
));
Some(PanelHandles {
panel: panel.kind,
layout,
available,
rotation,
})
}
#[must_use]
pub fn place_handles(
frame: &FacetFrame,
layout: &DiagramLayout,
preferred: Option<PanelKind>,
) -> Option<PanelHandles> {
[
preferred,
Some(PanelKind::Crown),
Some(PanelKind::Pavilion),
Some(PanelKind::Profile),
]
.into_iter()
.flatten()
.filter_map(|kind| layout.panel(kind))
.find_map(|panel| panel_handles(frame, panel).filter(|handles| handles.available.any()))
}
#[must_use]
pub fn candidate_facets(
remembered: Option<u32>,
tier: usize,
facets_of_tier: &[u32],
tier_of: impl Fn(u32) -> Option<usize>,
) -> Vec<u32> {
let first = remembered.filter(|&id| tier_of(id) == Some(tier));
first
.into_iter()
.chain(
facets_of_tier
.iter()
.copied()
.filter(|&id| Some(id) != first),
)
.collect()
}
#[must_use]
pub fn zoomed_hit_radius(radius_px: f32, zoom: f32) -> f32 {
if zoom.is_finite() && zoom > 1.0 {
radius_px / zoom
} else {
radius_px
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct IndexRotation {
center: ScreenPoint,
mirrored: bool,
gear_teeth: u32,
last_angle: Option<f32>,
turn: f64,
}
impl IndexRotation {
#[must_use]
pub const fn new(center: ScreenPoint, mirrored: bool, gear_teeth: u32) -> Self {
Self {
center,
mirrored,
gear_teeth,
last_angle: None,
turn: 0.0,
}
}
#[must_use]
pub const fn center(&self) -> ScreenPoint {
self.center
}
fn angle_of(&self, pointer: ScreenPoint) -> Option<f32> {
let (dx, dy) = self.center.delta_to(pointer);
(dx.hypot(dy) >= MIN_ROTATION_RADIUS_PX).then(|| dy.atan2(dx))
}
pub fn begin(&mut self, pointer: ScreenPoint) {
self.turn = 0.0;
self.last_angle = self.angle_of(pointer);
}
pub fn teeth_at(&mut self, pointer: ScreenPoint) -> i64 {
if let Some(angle) = self.angle_of(pointer) {
if let Some(last) = self.last_angle {
let step = wrap_half_turn(angle - last);
let sign: f64 = if self.mirrored { -1.0 } else { 1.0 };
self.turn = sign.mul_add(f64::from(step), self.turn);
}
self.last_angle = Some(angle);
}
let teeth = f64::from(self.gear_teeth.max(1));
(self.turn * teeth / std::f64::consts::TAU).round() as i64
}
}
fn wrap_half_turn(delta: f32) -> f32 {
let tau = std::f32::consts::TAU;
let mut wrapped = delta % tau;
if wrapped > std::f32::consts::PI {
wrapped -= tau;
} else if wrapped <= -std::f32::consts::PI {
wrapped += tau;
}
wrapped
}