use super::{
DiagramFrame, DiagramStyle, PanelKind,
fill::{draw_edge, to_px},
labels::{draw_text, text_size},
layout::{PanelLayout, wheel_direction},
render::WheelConfig,
};
const MAX_WHEEL_TICKS: u32 = 240;
fn tick_stride(gear_teeth: u32) -> u32 {
gear_teeth.div_ceil(MAX_WHEEL_TICKS).max(1)
}
pub fn draw_index_wheel(
frame: &mut DiagramFrame,
layout: &PanelLayout,
gear_teeth: u32,
gear_reference_angle: f32,
color: [u8; 3],
) {
let mirrored = matches!(layout.kind, PanelKind::Pavilion);
let major_every = if gear_teeth <= 64 { 4 } else { 8 };
let inner_r = layout.wheel_radius_px * 0.94;
let minor_outer_r = layout.wheel_radius_px;
let major_outer_r = layout.wheel_radius_px * 1.08;
let label_r = layout.wheel_radius_px * 1.2;
let stride = tick_stride(gear_teeth);
for tooth in (0..gear_teeth).step_by(stride as usize) {
let phi =
2.0 * std::f32::consts::PI * (tooth as f32 + gear_reference_angle) / gear_teeth as f32;
let (su, sv) = wheel_direction(phi, mirrored);
let is_major = (tooth / stride).is_multiple_of(major_every);
let outer_r = if is_major {
major_outer_r
} else {
minor_outer_r
};
let from = (
su.mul_add(inner_r, layout.center_x),
sv.mul_add(-inner_r, layout.center_y),
0.0,
);
let to = (
su.mul_add(outer_r, layout.center_x),
sv.mul_add(-outer_r, layout.center_y),
0.0,
);
draw_edge(frame, from, to, color, layout.clip, 1);
let mid_r = inner_r.midpoint(outer_r);
let mid_x = to_px(su.mul_add(mid_r, layout.center_x).round());
let mid_y = to_px(sv.mul_add(-mid_r, layout.center_y).round());
tag_tooth_hit(frame, mid_x, mid_y, tooth, 4);
if is_major {
let label = tooth.to_string();
let (w, h) = text_size(&label, 1);
let lx = su.mul_add(label_r, layout.center_x) - w as f32 / 2.0;
let ly = sv.mul_add(-label_r, layout.center_y) - h as f32 / 2.0;
let lx = lx.clamp(layout.clip.0 as f32, (layout.clip.2 as f32) - w as f32);
let ly = ly.clamp(layout.clip.1 as f32, (layout.clip.3 as f32) - h as f32);
draw_text(frame, lx, ly, &label, 1, color, Some(layout.clip));
}
}
}
fn tag_tooth_hit(frame: &mut DiagramFrame, cx: i32, cy: i32, tooth: u32, radius: i32) {
for dy in -radius..=radius {
for dx in -radius..=radius {
if let Some(idx) = frame.idx(cx + dx, cy + dy) {
frame.tooth[idx] = tooth + 1;
}
}
}
}
fn symmetry_line_steps(symmetry_order: u32) -> impl Iterator<Item = u32> {
(0..symmetry_order).step_by(tick_stride(symmetry_order) as usize)
}
pub fn draw_symmetry_and_mirror_lines(
frame: &mut DiagramFrame,
layout: &PanelLayout,
wheel: WheelConfig,
style: &DiagramStyle,
) {
let mirrored = matches!(layout.kind, PanelKind::Pavilion);
let line_len = layout.wheel_radius_px * 1.05;
let center = (layout.center_x, layout.center_y, 0.0);
if wheel.symmetry_order > 1 {
for k in symmetry_line_steps(wheel.symmetry_order) {
let phi = 2.0 * std::f32::consts::PI * (k as f32) / (wheel.symmetry_order as f32);
let (su, sv) = wheel_direction(phi, mirrored);
let tip = (
su.mul_add(line_len, layout.center_x),
sv.mul_add(-line_len, layout.center_y),
0.0,
);
draw_edge(
frame,
center,
tip,
style.symmetry_line_color,
layout.clip,
1,
);
}
}
if wheel.mirror {
let top = (layout.center_x, layout.center_y - line_len, 0.0);
let bottom = (layout.center_x, layout.center_y + line_len, 0.0);
draw_edge(frame, top, bottom, style.mirror_line_color, layout.clip, 2);
}
}
pub fn draw_selected_index_radials(
frame: &mut DiagramFrame,
layout: &PanelLayout,
gear_teeth: u32,
gear_reference_angle: f32,
style: &DiagramStyle,
edge_ranges: &[(usize, usize, usize)],
) {
let mirrored = matches!(layout.kind, PanelKind::Pavilion);
for &(facet_id, _start, _count) in edge_ranges {
let facet_key = u32::try_from(facet_id).expect("a facet id fits in u32");
let color = if style.selected_facet == Some(facet_key) {
style.selected_facet_color
} else if style.selected.get(facet_id).copied().unwrap_or(false) {
style.selected_color
} else if style.multi_selected.contains(&facet_key) {
style.multi_selected_color
} else {
continue;
};
let Some(&index) = style.facet_index_on_gear.get(facet_id) else {
continue;
};
let phi = 2.0 * std::f32::consts::PI * (index as f32 + gear_reference_angle)
/ gear_teeth.max(1) as f32;
let (su, sv) = wheel_direction(phi, mirrored);
let center = (layout.center_x, layout.center_y, 0.0);
let tip = (
su.mul_add(layout.wheel_radius_px, layout.center_x),
sv.mul_add(-layout.wheel_radius_px, layout.center_y),
0.0,
);
draw_edge(frame, center, tip, color, layout.clip, 2);
}
}
#[cfg(test)]
mod tests {
use super::{
super::{DiagramFrame, DiagramStyle, PanelKind, layout::PanelLayout, render::WheelConfig},
MAX_WHEEL_TICKS, draw_symmetry_and_mirror_lines, symmetry_line_steps, tick_stride,
};
#[test]
fn a_hostile_symmetry_order_draws_a_bounded_number_of_lines() {
assert_eq!(symmetry_line_steps(8).count(), 8);
for order in [241, 720, 100_000, 4_000_000_000, u32::MAX] {
let count = symmetry_line_steps(order).count();
assert!(
(1..=MAX_WHEEL_TICKS as usize).contains(&count),
"{order} drew {count}"
);
}
let style = DiagramStyle::default();
let mut frame = DiagramFrame::blank(64, 64, style.background);
let blank = frame.color.clone();
let layout = PanelLayout {
kind: PanelKind::Crown,
center_x: 32.0,
center_y: 32.0,
scale: 1.0,
wheel_radius_px: 28.0,
clip: (0, 0, 63, 63),
};
let wheel = WheelConfig {
gear_teeth: 96,
gear_reference_angle: 0.0,
symmetry_order: 4_000_000_000,
mirror: false,
};
draw_symmetry_and_mirror_lines(&mut frame, &layout, wheel, &style);
assert_ne!(frame.color, blank, "the decimated lines are still drawn");
}
#[test]
fn a_wheel_up_to_the_cap_keeps_every_tick() {
for teeth in [0, 1, 64, 96, MAX_WHEEL_TICKS] {
assert_eq!(tick_stride(teeth), 1, "{teeth} teeth");
}
}
#[test]
fn a_larger_wheel_draws_at_most_the_cap() {
for teeth in [241, 480, 720, 100_000, 2_000_000_000, u32::MAX] {
let stride = tick_stride(teeth);
assert!(stride > 1, "{teeth} teeth");
assert!(
teeth.div_ceil(stride) <= MAX_WHEEL_TICKS,
"{teeth} teeth drew {} ticks",
teeth.div_ceil(stride)
);
}
}
}