sim_logic/rendering/extraction/
composition.rs1use std::mem::size_of;
4
5use sim_engine::{Color, SceneBudget, ScreenScene};
6
7use super::{
8 super::{ExtractionError, compare_visual_order},
9 ResolvedScreenPrimitive, ScreenExtractionBuffer,
10};
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
19pub enum ScreenDraw {
20 Primitives {
22 run: usize,
24 },
25 Rectangles {
27 run: usize,
29 },
30 Image {
32 index: usize,
34 },
35 #[cfg(feature = "headless-text")]
37 Text {
38 index: usize,
40 },
41}
42
43#[derive(Clone, Copy)]
44enum NonRectangleKind {
45 Image,
46 #[cfg(feature = "headless-text")]
47 Text,
48}
49
50pub(super) struct RectangleRun {
51 pub(super) start: usize,
52 pub(super) end: usize,
53 pub(super) scene: ScreenScene,
54 pub(super) records: Vec<ResolvedScreenPrimitive>,
55}
56
57impl ScreenExtractionBuffer {
58 pub(super) fn compose(&mut self, budget: SceneBudget) -> Result<(), ExtractionError> {
59 let result = self.compose_inner(budget);
60 if result.is_err() {
61 self.runs.clear();
64 self.draws.clear();
65 }
66 result
67 }
68
69 fn compose_inner(&mut self, budget: SceneBudget) -> Result<(), ExtractionError> {
70 self.draws.clear();
71 if !self.has_non_rectangles() {
72 self.runs.clear();
75 if self.geometry_len() != 0 {
76 self.push_draw(self.geometry_draw(0))?;
77 }
78 return Ok(());
79 }
80
81 let mut rectangle = 0;
82 let mut image = 0;
83 #[cfg(feature = "headless-text")]
84 let mut text = 0;
85 let mut run_start = 0;
86 let mut run_count = 0;
87 loop {
88 let next = self.images.get(image).map(|image| {
89 (
90 NonRectangleKind::Image,
91 image.layer(),
92 image.draw_order_depth(),
93 image.source(),
94 )
95 });
96 #[cfg(feature = "headless-text")]
97 let next = match (next, self.texts.get(text)) {
98 (Some(image), Some(text))
99 if !compare_visual_order(
100 image.1,
101 image.2,
102 image.3,
103 text.layer(),
104 text.draw_order_depth(),
105 text.source(),
106 )
107 .is_gt() =>
108 {
109 Some(image)
110 }
111 (_, Some(text)) => Some((
112 NonRectangleKind::Text,
113 text.layer(),
114 text.draw_order_depth(),
115 text.source(),
116 )),
117 (image, None) => image,
118 };
119 let take_rectangle = match (self.geometry(rectangle), next) {
120 (Some(left), Some(right)) => !compare_visual_order(
121 left.layer(),
122 left.draw_order_depth(),
123 left.source(),
124 right.1,
125 right.2,
126 right.3,
127 )
128 .is_gt(),
129 (Some(_), None) => true,
130 (None, Some(_)) => false,
131 (None, None) => break,
132 };
133 if take_rectangle {
134 rectangle += 1;
135 } else if let Some((kind, _, _, _)) = next {
136 if run_start != rectangle {
137 self.prepare_run(run_count, run_start, rectangle, budget)?;
138 self.push_draw(self.geometry_draw(run_count))?;
139 run_count += 1;
140 }
141 match kind {
142 NonRectangleKind::Image => {
143 self.push_draw(ScreenDraw::Image { index: image })?;
144 image += 1;
145 }
146 #[cfg(feature = "headless-text")]
147 NonRectangleKind::Text => {
148 self.push_draw(ScreenDraw::Text { index: text })?;
149 text += 1;
150 }
151 }
152 run_start = rectangle;
153 }
154 }
155 if run_start != rectangle {
156 self.prepare_run(run_count, run_start, rectangle, budget)?;
157 self.push_draw(self.geometry_draw(run_count))?;
158 run_count += 1;
159 }
160 self.runs.truncate(run_count);
161 Ok(())
162 }
163
164 fn push_draw(&mut self, draw: ScreenDraw) -> Result<(), ExtractionError> {
165 self.draws
166 .try_reserve(1)
167 .map_err(|_| ExtractionError::AllocationFailed {
168 requested_bytes: size_of::<ScreenDraw>(),
169 })?;
170 self.draws.push(draw);
171 Ok(())
172 }
173
174 fn prepare_run(
175 &mut self,
176 index: usize,
177 start: usize,
178 end: usize,
179 budget: SceneBudget,
180 ) -> Result<(), ExtractionError> {
181 let count = end - start;
182 if self.runs.get(index).is_some_and(|run| {
183 run.records
184 .iter()
185 .cloned()
186 .eq((start..end).filter_map(|position| self.geometry(position)))
187 }) {
188 self.runs[index].start = start;
189 self.runs[index].end = end;
190 self.updates.reused_runs += 1;
191 return Ok(());
192 }
193 let run_budget = SceneBudget::new(
198 count,
199 budget.max_points(),
200 budget.max_tessellated_vertices(),
201 budget.max_retained_bytes(),
202 budget.max_allocation_bytes(),
203 budget.max_upload_bytes(),
204 budget.max_draw_batches(),
205 );
206 if index == self.runs.len() {
207 self.runs
208 .try_reserve(1)
209 .map_err(|_| ExtractionError::AllocationFailed {
210 requested_bytes: size_of::<RectangleRun>(),
211 })?;
212 let scene = ScreenScene::with_budget(Color::TRANSPARENT, run_budget)
213 .map_err(ExtractionError::ScreenScene)?;
214 self.runs.push(RectangleRun {
215 start,
216 end,
217 scene,
218 records: Vec::new(),
219 });
220 } else if self.runs[index].end - self.runs[index].start != count {
221 self.runs[index].scene = ScreenScene::with_budget(Color::TRANSPARENT, run_budget)
224 .map_err(ExtractionError::ScreenScene)?;
225 self.runs[index].records = Vec::new();
226 }
227 self.runs[index].start = start;
228 self.runs[index].end = end;
229 self.runs[index].scene.clear();
230 self.runs[index].records.clear();
231 self.runs[index]
232 .records
233 .try_reserve_exact(count)
234 .map_err(|_| ExtractionError::AllocationFailed {
235 requested_bytes: count.saturating_mul(size_of::<ResolvedScreenPrimitive>()),
236 })?;
237 for position in start..end {
238 if let Some(primitive) = self.geometry(position) {
239 primitive
240 .append(&mut self.runs[index].scene)
241 .map_err(ExtractionError::ScreenScene)?;
242 self.runs[index].records.push(primitive);
243 }
244 }
245 self.updates.rebuilt_runs += 1;
246 Ok(())
247 }
248}