use crate::cpu::{CpuRasterizer, CpuRenderOptions, Scene3DImage};
use ferroui_base::rendering::scene3d::Scene3DSnapshot;
use ferroui_base::PixelSize;
use std::sync::{Arc, Weak};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct OutputKey {
generations: (u64, u64, u64),
size: (i32, i32),
scale_bits: u64,
options: CpuRenderOptions,
}
struct OutputEntry<T> {
scene: Weak<Scene3DSnapshot>,
key: OutputKey,
value: T,
last_used: u64,
}
pub struct Scene3DOutputCache<T> {
rasterizer: CpuRasterizer,
entries: Vec<OutputEntry<T>>,
capacity: usize,
clock: u64,
}
impl<T: Clone> Default for Scene3DOutputCache<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: Clone> Scene3DOutputCache<T> {
pub const DEFAULT_CAPACITY: usize = 8;
pub fn new() -> Self {
Self::with_capacity(Self::DEFAULT_CAPACITY)
}
pub fn with_capacity(capacity: usize) -> Self {
Scene3DOutputCache { rasterizer: CpuRasterizer::new(), entries: Vec::new(), capacity: capacity.max(1), clock: 0 }
}
pub fn get_or_render(
&mut self,
scene: &Arc<Scene3DSnapshot>,
size: PixelSize,
scale: f64,
options: CpuRenderOptions,
make: impl FnOnce(Scene3DImage) -> Option<T>,
) -> Option<T> {
self.clock += 1;
let key = OutputKey {
generations: scene.generations(),
size: (size.width, size.height),
scale_bits: scale.to_bits(),
options,
};
self.entries.retain(|entry| entry.scene.strong_count() > 0);
let same_scene = |entry: &OutputEntry<T>| std::ptr::eq(entry.scene.as_ptr(), Arc::as_ptr(scene));
if let Some(entry) = self.entries.iter_mut().find(|entry| same_scene(entry) && entry.key == key) {
entry.last_used = self.clock;
return Some(entry.value.clone());
}
let image = self.rasterizer.render(scene, size, scale, options);
let value = make(image)?;
self.entries.retain(|entry| !same_scene(entry));
if self.entries.len() >= self.capacity {
if let Some(oldest) =
self.entries.iter().enumerate().min_by_key(|(_, entry)| entry.last_used).map(|(index, _)| index)
{
self.entries.swap_remove(oldest);
}
}
self.entries.push(OutputEntry { scene: Arc::downgrade(scene), key, value: value.clone(), last_used: self.clock });
Some(value)
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn clear(&mut self) {
self.entries.clear();
}
}
#[cfg(test)]
#[path = "output_cache_tests.rs"]
mod tests;