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(
cached: &CachedMesh,
size: (u32, u32),
last_diagram: &DiagramMemory,
moved: &[u32],
) -> 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()
})
};
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,
out_of_date,
unsolvable_status,
generation,
known_key,
) = resolve_request_state(memory, mesh_cache, request)?;
let style = memory.with_outlines(style);
let view_mode = match view_mode {
0..=4 => view_mode,
_ => 0,
};
rasterizer.resize(size.0, size.1);
let camera = Camera::new(
camera_pose.yaw,
camera_pose.pitch,
camera_pose.distance,
DEFAULT_FOV_DEG,
);
let mut has_edges = false;
let mut diagram = None;
let mut closed_geometry = None;
let stone_key = known_key.unwrap_or_else(|| stone.cache_key());
let (has_solid, status) =
if let Some(cached) = mesh_cache.get_or_build_geometry_keyed(stone_key, &stone) {
rasterizer.render_prepared(cached, &camera, &style);
if view_mode == 2 {
edges_rasterizer.resize(size.0, size.1);
render_edges_layer(edges_rasterizer, cached, &camera, &style);
has_edges = true;
}
if view_mode == 3 {
diagram = Some(build_diagram(cached, size, &memory.diagram, &style.moved));
}
closed_geometry = Some(frame_geometry(cached, camera_pose, size));
(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 (diagram_hover_text, diagram_facet_tier, diagram_facet_concave_tier) = if view_mode == 3 {
(
Some(memory.diagram.hover_text.clone()),
Some(memory.diagram.facet_tier.clone()),
Some(memory.diagram.facet_concave_tier.clone()),
)
} else {
(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 = closed_geometry.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: out_of_date,
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,
})
}