use super::{
request::RedrawRequest,
state::{DiagramMemory, WorkerMemory, dim_style, resolve_request_state},
types::{CameraPose, FrameGeometry, PickBuffer},
};
use crate::{
diagram2d::{self, DiagramConfig, DiagramFrame},
edges_layer::render_edges_layer,
mesh_cache::{CachedMesh, MeshCache},
raster::SolidRasterizer,
};
use glam::Vec3;
use indicatrix::{
geometry::{meet_solver::SolvedTier, stone_metrics::SolidMesh},
optics::raytracer::{Camera, DEFAULT_FOV_DEG},
};
use std::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 planes: Vec<(Vec3, f32)>,
pub hover_text: Vec<String>,
pub facet_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,
}
}
fn build_diagram(
mesh_cache: &mut MeshCache,
planes: &[(Vec3, f32)],
size: (u32, u32),
last_diagram: &DiagramMemory,
) -> Option<DiagramFrame> {
mesh_cache.get_or_build(planes).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, &last_diagram.style),
|panel| {
diagram2d::render_diagram_single_panel(
&cached.mesh,
&config,
&last_diagram.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 (planes, 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(&planes) {
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(&planes).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) = if view_mode == 3 {
(
build_diagram(mesh_cache, &planes, size, &memory.diagram),
Some(memory.diagram.hover_text.clone()),
Some(memory.diagram.facet_tier.clone()),
)
} else {
(None, None, None)
};
let hover_text = memory.diagram.hover_text.clone();
let facet_tier = memory.diagram.facet_tier.clone();
let geometry = mesh_cache
.get_or_build(&planes)
.map(|cached| frame_geometry(cached, camera_pose, size))
.or_else(|| {
mesh_cache
.last_closed()
.map(|cached| frame_geometry(cached, camera_pose, size))
});
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,
planes,
hover_text,
facet_tier,
generation,
mesh_bounding_radius,
geometry,
})
}