use super::{
request::RedrawRequest,
state::{DiagramMemory, WorkerMemory, dim_style, resolve_request_state},
types::{CameraPose, FrameGeometry, PickBuffer, StoneGeometryBuf},
};
use crate::{
diagram2d::{self, DiagramConfig, DiagramFrame, DiagramStyle},
edges_layer::render_edges_layer,
mesh_cache::{CachedMesh, MeshCache},
raster::SolidRasterizer,
};
use indicatrix::{
geometry::{meet_solver::SolvedTier, stone_metrics::SolidMesh},
optics::raytracer::{Camera, DEFAULT_FOV_DEG},
};
use std::{borrow::Cow, sync::Arc};
pub const DEFAULT_MESH_BOUNDING_RADIUS: f64 = 1.5;
pub struct RenderedFrame {
pub has_solid: bool,
pub status: String,
pub solved: Option<Vec<SolvedTier>>,
pub stale: bool,
pub pick: PickBuffer,
pub has_edges: bool,
pub diagram: Option<DiagramFrame>,
pub diagram_hover_text: Option<Vec<String>>,
pub diagram_facet_tier: Option<Vec<Option<usize>>>,
pub diagram_facet_concave_tier: Option<Vec<Option<usize>>>,
pub stone: StoneGeometryBuf,
pub hover_text: Vec<String>,
pub facet_tier: Vec<Option<usize>>,
pub facet_concave_tier: Vec<Option<usize>>,
pub generation: u64,
pub mesh_bounding_radius: f64,
pub geometry: Option<FrameGeometry>,
}
fn frame_geometry(cached: &CachedMesh, camera: CameraPose, size: (u32, u32)) -> FrameGeometry {
FrameGeometry {
corner_points: Arc::clone(&cached.corner_points),
facet_centroids: Arc::clone(&cached.facet_centroids),
bounding_radius: cached.bounding_radius(),
camera,
size,
diagram: None,
visible_tiers: None,
}
}
fn build_diagram(
mesh_cache: &mut MeshCache,
stone: &StoneGeometryBuf,
size: (u32, u32),
last_diagram: &DiagramMemory,
moved: &[u32],
) -> Option<DiagramFrame> {
let style = if last_diagram.style.moved == moved {
Cow::Borrowed(&last_diagram.style)
} else {
Cow::Owned(DiagramStyle {
moved: moved.to_vec(),
..last_diagram.style.clone()
})
};
mesh_cache.get_or_build_geometry(stone).map(|cached| {
let config = DiagramConfig {
width: size.0,
height: size.1,
gear_teeth: last_diagram.gear_teeth,
gear_reference_angle: last_diagram.gear_reference_angle,
symmetry_order: last_diagram.symmetry_order,
mirror: last_diagram.mirror,
};
last_diagram.enlarged_panel.map_or_else(
|| diagram2d::render_diagram(&cached.mesh, &config, &style),
|panel| diagram2d::render_diagram_single_panel(&cached.mesh, &config, &style, panel),
)
})
}
pub fn render_request(
mesh_cache: &mut MeshCache,
rasterizer: &mut SolidRasterizer,
edges_rasterizer: &mut SolidRasterizer,
memory: &mut WorkerMemory,
request: RedrawRequest,
) -> Option<RenderedFrame> {
let (stone, camera_pose, size, view_mode, style, solved, stale, unsolvable_status, generation) =
resolve_request_state(memory, mesh_cache, request)?;
let style = memory.with_outlines(style);
rasterizer.resize(size.0, size.1);
let camera = Camera::new(
camera_pose.yaw,
camera_pose.pitch,
camera_pose.distance,
DEFAULT_FOV_DEG,
);
let (has_solid, status) = if let Some(cached) = mesh_cache.get_or_build_geometry(&stone) {
rasterizer.render_prepared(cached, &camera, &style);
(true, String::new())
} else if let Some(cached) = mesh_cache.last_closed() {
let dimmed = dim_style(style.clone());
rasterizer.render_prepared(cached, &camera, &dimmed);
(true, mesh_cache.status_message())
} else {
rasterizer.render(&SolidMesh::default(), &camera, &style);
(false, mesh_cache.status_message())
};
let status = unsolvable_status.unwrap_or(status);
let pick = PickBuffer {
width: rasterizer.width,
height: rasterizer.height,
pick: rasterizer.pick.clone(),
};
let has_edges = view_mode == 2
&& mesh_cache
.get_or_build_geometry(&stone)
.is_some_and(|cached| {
edges_rasterizer.resize(size.0, size.1);
render_edges_layer(edges_rasterizer, cached, &camera, &style);
true
});
let (diagram, diagram_hover_text, diagram_facet_tier, diagram_facet_concave_tier) =
if view_mode == 3 {
(
build_diagram(mesh_cache, &stone, size, &memory.diagram, &style.moved),
Some(memory.diagram.hover_text.clone()),
Some(memory.diagram.facet_tier.clone()),
Some(memory.diagram.facet_concave_tier.clone()),
)
} else {
(None, None, None, None)
};
let hover_text = memory.diagram.hover_text.clone();
let facet_tier = memory.diagram.facet_tier.clone();
let facet_concave_tier = memory.diagram.facet_concave_tier.clone();
let geometry = mesh_cache
.get_or_build_geometry(&stone)
.map(|cached| frame_geometry(cached, camera_pose, size))
.or_else(|| {
mesh_cache
.last_closed()
.map(|cached| frame_geometry(cached, camera_pose, size))
});
let diagram_layout = diagram.as_ref().map(|drawn| Arc::new(drawn.layout.clone()));
let geometry = geometry.map(|shown| FrameGeometry {
diagram: diagram_layout,
visible_tiers: memory.visible_tiers.clone(),
..shown
});
let mesh_bounding_radius = geometry
.as_ref()
.map_or(DEFAULT_MESH_BOUNDING_RADIUS, |shown| shown.bounding_radius);
Some(RenderedFrame {
has_solid,
status,
solved,
stale,
pick,
has_edges,
diagram,
diagram_hover_text,
diagram_facet_tier,
diagram_facet_concave_tier,
stone,
hover_text,
facet_tier,
facet_concave_tier,
generation,
mesh_bounding_radius,
geometry,
})
}