use super::{
request::{PlannedFrame, RedrawRequest, panel_kind_from_index},
types::{CameraPose, StoneGeometryBuf},
};
use crate::{
diagram2d::{DiagramStyle, PanelKind},
facet_map::{FacetKind, FacetMap},
mesh_cache::MeshCache,
raster::SolidStyle,
};
use glam::Vec3;
use indicatrix::geometry::{ToolPrimitive, meet_solver::SolvedTier, stone_metrics::SolidStatus};
use std::sync::{Arc, Mutex, PoisonError};
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Outlines {
pub provisional: Vec<u32>,
pub moved: Vec<u32>,
}
pub type SharedOutlines = Arc<Mutex<Outlines>>;
pub struct DiagramMemory {
pub gear_teeth: u32,
pub gear_reference_angle: f32,
pub symmetry_order: u32,
pub mirror: bool,
pub enlarged_panel: Option<PanelKind>,
pub style: DiagramStyle,
pub hover_text: Vec<String>,
pub facet_tier: Vec<Option<usize>>,
pub facet_concave_tier: Vec<Option<usize>>,
}
impl Default for DiagramMemory {
fn default() -> Self {
Self {
gear_teeth: 96,
gear_reference_angle: 0.0,
symmetry_order: 8,
mirror: true,
enlarged_panel: None,
style: DiagramStyle::default(),
hover_text: Vec::new(),
facet_tier: Vec::new(),
facet_concave_tier: Vec::new(),
}
}
}
#[derive(Default)]
pub struct WorkerMemory {
pub style: SolidStyle,
pub diagram: DiagramMemory,
pub solved_masts: Option<Vec<SolvedTier>>,
pub planes: Option<Vec<(Vec3, f32)>>,
pub tools: Vec<ToolPrimitive>,
pub placements: Vec<(usize, usize)>,
pub camera: Option<CameraPose>,
pub size: Option<(u32, u32)>,
pub view_mode: Option<u8>,
pub generation: u64,
pub outlines: Option<SharedOutlines>,
pub visible_tiers: Option<Arc<Vec<bool>>>,
}
impl WorkerMemory {
#[must_use]
pub fn geometry(&self) -> Option<StoneGeometryBuf> {
self.planes.as_ref().map(|planes| {
let mut geometry = StoneGeometryBuf::from_halfspaces(planes);
geometry.tools.clone_from(&self.tools);
geometry.placements.clone_from(&self.placements);
geometry
})
}
#[must_use]
pub fn with_outlines(&self, mut style: SolidStyle) -> SolidStyle {
if let Some(shared) = &self.outlines {
let outlines = shared.lock().unwrap_or_else(PoisonError::into_inner);
style.provisional.clone_from(&outlines.provisional);
style.moved.clone_from(&outlines.moved);
}
style
}
}
#[must_use]
pub fn dim_style(style: SolidStyle) -> SolidStyle {
SolidStyle {
base_color: [120, 122, 128],
ambient: 0.4,
diffuse: 0.35,
..style
}
}
#[must_use]
pub fn escaping_tier_label(
design: &indicatrix_cut_core::Design,
solved: &[SolvedTier],
plane_index: usize,
) -> String {
design
.tier_for_plane_index(solved, plane_index)
.map_or_else(
|| format!("plane {plane_index}"),
|tier_index| {
design.tiers.get(tier_index).map_or_else(
|| format!("tier {}", tier_index + 1),
|tier| {
if tier.name.is_empty() {
format!("tier {}", tier_index + 1)
} else {
format!("{} (tier {})", tier.name, tier_index + 1)
}
},
)
},
)
}
fn update_diagram_memory_from_design(
last_diagram: &mut DiagramMemory,
design: &indicatrix_cut_core::Design,
solved: Option<&[SolvedTier]>,
solid_style: &SolidStyle,
n_d: f64,
placements: &[(usize, usize)],
visible_tiers: Option<&[bool]>,
) {
let facet_map =
FacetMap::from_design_cut(design, solved.unwrap_or(&[]), placements, visible_tiers);
let facet_count = facet_map.facet_count();
let mut labels = vec![String::new(); facet_count];
let mut hover_text = vec![String::new(); facet_count];
let mut facet_tier = vec![None; facet_count];
let mut facet_concave_tier = vec![None; facet_count];
let mut facet_index_on_gear = vec![0u32; facet_count];
for id in 0..facet_count {
labels[id] = facet_map.facet_label(id);
hover_text[id] = facet_map.hover_text(id, n_d);
facet_tier[id] = facet_map.tier_of(id);
facet_concave_tier[id] = match facet_map.kind_of(id) {
FacetKind::Concave { tier, .. } => Some(tier),
FacetKind::Flat => None,
};
facet_index_on_gear[id] = facet_map.index_on_gear(id);
}
last_diagram.style = DiagramStyle {
flagged: solid_style.flagged.clone(),
pending: solid_style.pending.clone(),
selected: solid_style.selected.clone(),
facet_labels: labels,
facet_index_on_gear,
meet_marker_pairs: facet_map.meeting_facet_pairs(design),
tool_facet_block: facet_map.tool_facet_blocks(),
..DiagramStyle::default()
};
last_diagram.hover_text = hover_text;
last_diagram.facet_tier = facet_tier;
last_diagram.facet_concave_tier = facet_concave_tier;
}
const fn apply_reproject_gear(last_diagram: &mut DiagramMemory, gear: Option<(u32, f32)>) {
if let Some((gear_teeth, gear_reference_angle)) = gear {
last_diagram.gear_teeth = gear_teeth;
last_diagram.gear_reference_angle = gear_reference_angle;
}
}
pub type RequestState = (
StoneGeometryBuf,
CameraPose,
(u32, u32),
u8,
SolidStyle,
Option<Vec<SolvedTier>>,
bool,
Option<String>,
u64,
);
pub fn resolve_request_state(
memory: &mut WorkerMemory,
mesh_cache: &mut MeshCache,
request: RedrawRequest,
) -> Option<RequestState> {
match request {
RedrawRequest::Reproject {
geometry,
camera,
size,
view_mode,
gear,
} => {
apply_reproject_gear(&mut memory.diagram, gear);
let planes = geometry.halfspaces();
if memory.planes.as_deref() != Some(planes.as_slice()) || memory.tools != geometry.tools
{
memory.style = SolidStyle::default();
memory.diagram = DiagramMemory::default();
memory.visible_tiers = None;
}
memory.planes = Some(planes);
memory.tools.clone_from(&geometry.tools);
memory.placements.clone_from(&geometry.placements);
memory.camera = Some(camera);
memory.size = Some(size);
memory.view_mode = Some(view_mode);
Some((
geometry,
camera,
size,
view_mode,
memory.style.clone(),
memory.solved_masts.clone(),
false,
None,
memory.generation,
))
}
RedrawRequest::UpdateFacetOverlay(overlay) => {
memory.size?;
memory.style.hovered = overlay.hovered;
memory.style.selected_facet = overlay.selected_facet;
memory.style.multi_selected = overlay.multi_selected.clone();
memory.style.provisional = overlay.provisional;
memory.style.moved = overlay.moved;
memory.diagram.style.hovered = overlay.hovered;
memory.diagram.style.selected_facet = overlay.selected_facet;
memory.diagram.style.multi_selected = overlay.multi_selected;
Some((
memory.geometry().unwrap_or_default(),
memory.camera.unwrap_or(CameraPose {
yaw: 0.0,
pitch: 0.0,
distance: 5.0,
}),
memory.size.unwrap_or((1, 1)),
memory.view_mode.unwrap_or(0),
memory.style.clone(),
memory.solved_masts.clone(),
false,
None,
memory.generation,
))
}
RedrawRequest::Planned(frame) => Some(resolve_planned_state(memory, mesh_cache, *frame)),
}
}
fn resolve_planned_state(
memory: &mut WorkerMemory,
mesh_cache: &mut MeshCache,
frame: PlannedFrame,
) -> RequestState {
let PlannedFrame {
design,
planes,
tools,
placements,
style,
solved,
stale,
unsolvable_status,
camera,
size,
view_mode,
generation,
n_d,
enlarged_panel,
visible_tiers,
} = frame;
let geometry = StoneGeometryBuf {
tools,
placements,
..StoneGeometryBuf::from_halfspaces(&planes)
};
let closes = mesh_cache.get_or_build_geometry(&geometry).is_some();
let unbounded_status = if unsolvable_status.is_none() && !closes {
match mesh_cache.status() {
Some(SolidStatus::Unbounded { escaping }) => {
let solved_ref = solved.as_deref().unwrap_or(&[]);
let names = escaping
.iter()
.map(|&plane_index| escaping_tier_label(&design, solved_ref, plane_index))
.collect::<Vec<_>>()
.join(", ");
Some(format!("Unbounded: {names} never close the solid."))
}
_ => None,
}
} else {
None
};
let holding_over = unsolvable_status.is_some() || unbounded_status.is_some();
let preview_status = unsolvable_status.or(unbounded_status);
let style = if holding_over {
dim_style(style)
} else {
style
};
memory.style = style.clone();
memory.visible_tiers = visible_tiers.clone().map(Arc::new);
if solved.is_some() {
memory.solved_masts.clone_from(&solved);
}
memory.planes = Some(planes);
memory.tools.clone_from(&geometry.tools);
memory.placements.clone_from(&geometry.placements);
memory.camera = Some(camera);
memory.size = Some(size);
memory.view_mode = Some(view_mode);
memory.generation = generation;
memory.diagram.gear_teeth = design.meta.gear_teeth_abs();
memory.diagram.gear_reference_angle = design.meta.gear_reference_angle as f32;
memory.diagram.symmetry_order = design.meta.symmetry_order;
memory.diagram.mirror = design.meta.mirror;
memory.diagram.enlarged_panel = panel_kind_from_index(enlarged_panel);
update_diagram_memory_from_design(
&mut memory.diagram,
&design,
solved.as_deref(),
&style,
n_d,
&geometry.placements,
visible_tiers.as_deref(),
);
(
geometry,
camera,
size,
view_mode,
style,
solved,
stale,
preview_status,
generation,
)
}