mod app;
mod library;
mod output;
mod render;
mod solid;
use crate::guide::{EIGHT_FOLD_INDICES, Goal, GoalContext, Group, Guide, same_index_set};
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::{ConstraintTier, Design};
const MAIN: [f64; 8] = EIGHT_FOLD_INDICES;
const GIRDLE: [f64; 16] = [
0.0, 6.0, 12.0, 18.0, 24.0, 30.0, 36.0, 42.0, 48.0, 54.0, 60.0, 66.0, 72.0, 78.0, 84.0, 90.0,
];
struct Original {
name: &'static str,
angle_deg: f64,
mast: f64,
indices: &'static [f64],
}
const RICH: [Original; 4] = [
Original {
name: "Table",
angle_deg: 0.0,
mast: 0.30,
indices: &[],
},
Original {
name: "Crown Main",
angle_deg: 34.5,
mast: 0.60,
indices: &MAIN,
},
Original {
name: "Girdle",
angle_deg: 90.0,
mast: 1.0,
indices: &GIRDLE,
},
Original {
name: "Pavilion Main",
angle_deg: -40.0,
mast: 0.70,
indices: &MAIN,
},
];
const ANGLE_SLACK_DEG: f64 = 0.05;
const MAST_SLACK: f64 = 0.005;
const VIEWPORT: &[Group] = &[Group::History];
const VIEWPORT_TABLE: &[Group] = &[Group::TierTable, Group::History];
const VIEWPORT_TABS: &[Group] = &[Group::ViewTabs, Group::History];
const FILES: &[Group] = &[Group::FileOps, Group::History];
const ADVANCED: &[Group] = &[Group::Advanced, Group::History];
#[must_use]
pub fn guides() -> Vec<Guide> {
let mut guides = Vec::new();
guides.extend(solid::guides());
guides.extend(render::guides());
guides.extend(output::guides());
guides.extend(library::guides());
guides.extend(app::guides());
guides
}
const fn check(label: &'static str, test: fn(&GoalContext<'_>) -> bool) -> Goal {
Goal::Check { label, test }
}
fn event(name: &str) -> Goal {
Goal::Event(name.to_owned())
}
fn tier_called<'a>(design: &'a Design, name: &str) -> Option<&'a ConstraintTier> {
design.tiers.iter().find(|tier| {
tier.names()
.iter()
.any(|known| known.trim().eq_ignore_ascii_case(name.trim()))
})
}
fn counterpart<'a>(design: &'a Design, original: &Original) -> Option<&'a ConstraintTier> {
tier_called(design, original.name)
}
fn angle_moved(ctx: &GoalContext<'_>) -> bool {
RICH.iter().any(|original| {
counterpart(ctx.design, original)
.is_some_and(|tier| (tier.angle_deg - original.angle_deg).abs() > ANGLE_SLACK_DEG)
})
}
fn depth_moved(ctx: &GoalContext<'_>) -> bool {
RICH.iter().any(|original| {
counterpart(ctx.design, original).is_some_and(|tier| {
!matches!(
&tier.constraint,
MeetConstraint::ScaleReference(mast) if (mast - original.mast).abs() <= MAST_SLACK
)
})
})
}
fn index_moved(ctx: &GoalContext<'_>) -> bool {
let gear = f64::from(ctx.design.meta.gear_teeth_abs());
RICH.iter().any(|original| {
counterpart(ctx.design, original)
.is_some_and(|tier| !same_index_set(&tier.indices, original.indices, gear))
})
}
fn rich_untouched(ctx: &GoalContext<'_>) -> bool {
ctx.design.tiers.len() == RICH.len()
&& !angle_moved(ctx)
&& !depth_moved(ctx)
&& !index_moved(ctx)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{EditorSession, templates::template_spec};
use indicatrix_cut_core::MaterialSelection;
use std::time::Duration;
fn rich_session() -> EditorSession {
let spec = template_spec(5).expect("the template exists");
EditorSession::from_template(spec.fresh_spec(MaterialSelection::none()), 5)
}
fn row(session: &EditorSession, name: &str) -> usize {
session
.design
.tiers
.iter()
.position(|tier| tier.names().iter().any(|known| known.trim() == name))
.unwrap_or_else(|| panic!("no tier is called {name:?}"))
}
const NOW: Duration = Duration::from_millis(100);
#[test]
fn the_numbers_in_rich_are_the_real_template() {
let session = rich_session();
assert_eq!(session.design.tiers.len(), RICH.len());
let gear = f64::from(session.design.meta.gear_teeth_abs());
for original in &RICH {
let tier = counterpart(&session.design, original)
.unwrap_or_else(|| panic!("the template has no tier {:?}", original.name));
assert!(
(tier.angle_deg - original.angle_deg).abs() < 1e-9,
"{}: angle {} against {}",
original.name,
tier.angle_deg,
original.angle_deg
);
assert!(
matches!(
&tier.constraint,
MeetConstraint::ScaleReference(mast) if (mast - original.mast).abs() < 1e-9
),
"{}: constraint {:?} against mast {}",
original.name,
tier.constraint,
original.mast
);
assert!(
same_index_set(&tier.indices, original.indices, gear),
"{}: indices {:?} against {:?}",
original.name,
tier.indices,
original.indices
);
}
}
#[test]
fn the_untouched_design_has_no_move() {
let session = rich_session();
let ctx = GoalContext::new(&session.design);
assert!(!angle_moved(&ctx));
assert!(!depth_moved(&ctx));
assert!(!index_moved(&ctx));
assert!(rich_untouched(&ctx));
}
#[test]
fn an_angle_drag_counts_as_an_angle_and_nothing_else() {
let mut session = rich_session();
let at = row(&session, "Crown Main");
session
.set_tier_angle(at, 38.0, NOW)
.expect("the drag applies")
.expect("the angle changed");
let ctx = GoalContext::new(&session.design);
assert!(angle_moved(&ctx));
assert!(!index_moved(&ctx));
assert!(!rich_untouched(&ctx));
}
#[test]
fn a_depth_drag_counts_as_a_depth() {
let mut session = rich_session();
let at = row(&session, "Pavilion Main");
session
.pin_tier_mast(at, 0.65, NOW)
.expect("the drag applies")
.expect("the mast changed");
let ctx = GoalContext::new(&session.design);
assert!(depth_moved(&ctx));
assert!(!angle_moved(&ctx));
assert!(!rich_untouched(&ctx));
}
#[test]
fn turning_a_ring_counts_as_an_index_move() {
let mut session = rich_session();
let at = row(&session, "Crown Main");
session
.rotate_tier_indices(at, 2, NOW)
.expect("the drag applies")
.expect("the tier turned");
let ctx = GoalContext::new(&session.design);
assert!(index_moved(&ctx));
assert!(!angle_moved(&ctx));
assert!(!rich_untouched(&ctx));
}
#[test]
fn the_same_positions_in_another_order_are_not_a_move() {
let session = rich_session();
let mut design = session.design.clone();
let at = row(&session, "Girdle");
design.tiers[at].indices.reverse();
assert!(!index_moved(&GoalContext::new(&design)));
}
#[test]
fn a_tier_that_is_gone_is_not_untouched() {
let mut session = rich_session();
session.design.tiers.pop();
assert!(!rich_untouched(&GoalContext::new(&session.design)));
}
#[test]
fn tiers_are_found_by_name_ignoring_case_and_spaces() {
let session = rich_session();
let mut design = session.design.clone();
let at = row(&session, "Crown Main");
design.tiers[at].angle_deg = 50.0;
assert!(angle_moved(&GoalContext::new(&design)));
assert!(tier_called(&design, " crown main ").is_some());
assert!(tier_called(&design, "No Such Tier").is_none());
}
}