ferroui_render3d/
output_cache.rs1use crate::cpu::{CpuRasterizer, CpuRenderOptions, Scene3DImage};
9use ferroui_base::rendering::scene3d::Scene3DSnapshot;
10use ferroui_base::PixelSize;
11use std::sync::{Arc, Weak};
12
13#[derive(Clone, Copy, Debug, PartialEq, Eq)]
15struct OutputKey {
16 generations: (u64, u64, u64),
17 size: (i32, i32),
18 scale_bits: u64,
19 options: CpuRenderOptions,
20}
21
22struct OutputEntry<T> {
23 scene: Weak<Scene3DSnapshot>,
28 key: OutputKey,
29 value: T,
30 last_used: u64,
31}
32
33pub struct Scene3DOutputCache<T> {
35 rasterizer: CpuRasterizer,
36 entries: Vec<OutputEntry<T>>,
37 capacity: usize,
38 clock: u64,
39}
40
41impl<T: Clone> Default for Scene3DOutputCache<T> {
42 fn default() -> Self {
43 Self::new()
44 }
45}
46
47impl<T: Clone> Scene3DOutputCache<T> {
48 pub const DEFAULT_CAPACITY: usize = 8;
50
51 pub fn new() -> Self {
53 Self::with_capacity(Self::DEFAULT_CAPACITY)
54 }
55
56 pub fn with_capacity(capacity: usize) -> Self {
58 Scene3DOutputCache { rasterizer: CpuRasterizer::new(), entries: Vec::new(), capacity: capacity.max(1), clock: 0 }
59 }
60
61 pub fn get_or_render(
67 &mut self,
68 scene: &Arc<Scene3DSnapshot>,
69 size: PixelSize,
70 scale: f64,
71 options: CpuRenderOptions,
72 make: impl FnOnce(Scene3DImage) -> Option<T>,
73 ) -> Option<T> {
74 self.clock += 1;
75 let key = OutputKey {
76 generations: scene.generations(),
77 size: (size.width, size.height),
78 scale_bits: scale.to_bits(),
79 options,
80 };
81 self.entries.retain(|entry| entry.scene.strong_count() > 0);
83 let same_scene = |entry: &OutputEntry<T>| std::ptr::eq(entry.scene.as_ptr(), Arc::as_ptr(scene));
84 if let Some(entry) = self.entries.iter_mut().find(|entry| same_scene(entry) && entry.key == key) {
85 entry.last_used = self.clock;
86 return Some(entry.value.clone());
87 }
88 let image = self.rasterizer.render(scene, size, scale, options);
89 let value = make(image)?;
90 self.entries.retain(|entry| !same_scene(entry));
91 if self.entries.len() >= self.capacity {
92 if let Some(oldest) =
93 self.entries.iter().enumerate().min_by_key(|(_, entry)| entry.last_used).map(|(index, _)| index)
94 {
95 self.entries.swap_remove(oldest);
96 }
97 }
98 self.entries.push(OutputEntry { scene: Arc::downgrade(scene), key, value: value.clone(), last_used: self.clock });
99 Some(value)
100 }
101
102 pub fn len(&self) -> usize {
104 self.entries.len()
105 }
106
107 pub fn is_empty(&self) -> bool {
109 self.entries.is_empty()
110 }
111
112 pub fn clear(&mut self) {
114 self.entries.clear();
115 }
116}
117
118#[cfg(test)]
119#[path = "output_cache_tests.rs"]
120mod tests;