use super::{
plan::build_planned_frame,
render::{RenderedFrame, render_request},
request::{PlanJob, PlannedFrame, RedrawRequest},
state::WorkerMemory,
types::{CameraPose, FacetOverlay},
};
use crate::{live_update::Clock, mesh_cache::MeshCache, raster::SolidRasterizer};
use std::time::Duration;
pub struct PreviewPipeline {
mesh_cache: MeshCache,
rasterizer: SolidRasterizer,
edges_rasterizer: SolidRasterizer,
memory: WorkerMemory,
}
impl Default for PreviewPipeline {
fn default() -> Self {
Self::new()
}
}
impl PreviewPipeline {
#[must_use]
pub fn new() -> Self {
Self {
mesh_cache: MeshCache::default(),
rasterizer: SolidRasterizer::new(1, 1),
edges_rasterizer: SolidRasterizer::new(1, 1),
memory: WorkerMemory::default(),
}
}
#[must_use]
pub fn plan(job: PlanJob, budget: Duration, clock: &dyn Clock) -> PlannedFrame {
build_planned_frame(job, budget, clock)
}
pub fn render_planned(&mut self, planned: PlannedFrame) -> Option<RenderedFrame> {
self.render(RedrawRequest::Planned(Box::new(planned)))
}
pub fn replan(
&mut self,
job: PlanJob,
budget: Duration,
clock: &dyn Clock,
) -> Option<RenderedFrame> {
let planned = Self::plan(job, budget, clock);
self.render_planned(planned)
}
pub fn reproject(
&mut self,
camera: CameraPose,
size: (u32, u32),
view_mode: u8,
gear: Option<(u32, f32)>,
) -> Option<RenderedFrame> {
let geometry = self.memory.geometry()?;
self.render(RedrawRequest::Reproject {
geometry,
camera,
size,
view_mode,
gear,
})
}
pub fn update_overlay(&mut self, overlay: FacetOverlay) -> Option<RenderedFrame> {
self.render(RedrawRequest::UpdateFacetOverlay(overlay))
}
pub fn render(&mut self, request: RedrawRequest) -> Option<RenderedFrame> {
render_request(
&mut self.mesh_cache,
&mut self.rasterizer,
&mut self.edges_rasterizer,
&mut self.memory,
request,
)
}
#[must_use]
pub fn solid_rgba(&self) -> &[u8] {
&self.rasterizer.color
}
#[must_use]
pub const fn size(&self) -> (u32, u32) {
(self.rasterizer.width, self.rasterizer.height)
}
#[must_use]
pub fn edges_rgba(&self) -> &[u8] {
&self.edges_rasterizer.color
}
#[must_use]
pub const fn memory(&self) -> &WorkerMemory {
&self.memory
}
}