sim_logic/rendering/extraction/
screen_cache.rs1use super::*;
3
4#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
11pub struct ScreenExtractionUpdates {
12 pub compared_sources: usize,
14 pub reused_snapshot: bool,
16 pub reused_scene: bool,
18 pub reused_runs: usize,
20 pub rebuilt_runs: usize,
22 pub retained_key_bytes: usize,
26}
27
28impl ScreenSource {
29 fn is_geometry(&self) -> bool {
30 match self {
31 Self::Rectangle(_) | Self::Line(..) | Self::Circle(..) | Self::Polyline(..) => true,
32 Self::Image(_) => false,
33 #[cfg(feature = "headless-text")]
34 Self::Text(_) => false,
35 }
36 }
37}
38
39impl ScreenExtractionBuffer {
40 pub(crate) fn extract(
41 &mut self,
42 generation: WorldGeneration,
43 limits: RenderLimits,
44 sources: impl IntoIterator<Item = ScreenSource>,
45 ) -> Result<(), ExtractionError> {
46 self.updates = ScreenExtractionUpdates::default();
47 let same_scope =
48 limits.screen_scene_reuse() && self.cache_scope == Some((generation, limits));
49 let mut sources = sources.into_iter().fuse();
50 let mut matched = 0;
51 let mut first_changed = None;
52 if same_scope {
53 for previous in &self.source_keys {
54 match sources.next() {
55 Some(current) => {
56 self.updates.compared_sources += 1;
57 if current == *previous {
58 matched += 1;
59 } else {
60 first_changed = Some(current);
61 break;
62 }
63 }
64 None => break,
65 }
66 }
67 if matched == self.source_keys.len() {
68 first_changed = sources.next();
69 if first_changed.is_none() {
70 self.updates.reused_snapshot = true;
71 self.updates.reused_scene = true;
72 self.updates.reused_runs = self.runs.len();
73 self.update_key_bytes();
74 return Ok(());
75 }
76 }
77 }
78 self.cache_scope = None;
80 let mut previous = std::mem::take(&mut self.source_keys);
81 self.source_keys = std::mem::take(&mut self.source_scratch);
82 self.source_keys.clear();
83 self.clear_sources();
84 if !same_scope {
85 for run in &mut self.runs {
88 run.records.clear();
89 }
90 }
91 let result = (|| {
92 self.collect_sources(
96 generation,
97 limits,
98 previous[..matched]
99 .iter()
100 .cloned()
101 .chain(first_changed)
102 .chain(sources),
103 )?;
104 let same_geometry = same_scope
105 && previous
106 .iter()
107 .filter(|key| key.is_geometry())
108 .eq(self.source_keys.iter().filter(|key| key.is_geometry()));
109 if same_geometry {
110 self.updates.reused_scene = true;
111 } else {
112 self.scene.clear();
113 for index in 0..self.geometry_len() {
114 if let Some(primitive) = self.geometry(index) {
115 primitive
116 .append(&mut self.scene)
117 .map_err(ExtractionError::ScreenScene)?;
118 }
119 }
120 }
121 self.compose(limits.screen_scene_budget())?;
122 Ok(())
123 })();
124 previous.clear();
126 self.source_scratch = previous;
127 if result.is_ok() {
128 self.cache_scope = Some((generation, limits));
129 } else {
130 self.clear();
131 }
132 self.update_key_bytes();
133 result
134 }
135
136 pub(super) fn remember_source(&mut self, key: ScreenSource) -> Result<(), ExtractionError> {
137 self.source_keys
139 .try_reserve(1)
140 .map_err(|_| ExtractionError::AllocationFailed {
141 requested_bytes: size_of::<ScreenSource>(),
142 })?;
143 self.source_keys.push(key);
144 Ok(())
145 }
146
147 fn update_key_bytes(&mut self) {
148 self.updates.retained_key_bytes = self
149 .source_keys
150 .capacity()
151 .saturating_add(self.source_scratch.capacity())
152 .saturating_mul(size_of::<ScreenSource>())
153 .saturating_add(
154 self.runs
155 .iter()
156 .map(|run| {
157 run.records
158 .capacity()
159 .saturating_mul(size_of::<ResolvedScreenPrimitive>())
160 })
161 .fold(0usize, usize::saturating_add),
162 );
163 }
164}
165
166#[cfg(test)]
167#[path = "screen_cache_tests.rs"]
168mod tests;