Skip to main content

sim_logic/rendering/extraction/
composition.rs

1//! Exact mixed screen ordering and bounded, reusable geometry runs.
2
3use 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/// One ordered screen source, after all world content.
13///
14/// Images index `ExtractedFrame::resolved_screen_images`; geometry runs are
15/// inspected with `ExtractedFrame::screen_primitive_run_records`. The older
16/// `screen_rectangle_run_records` selects only rectangles from a run. Indices
17/// belong only to their containing snapshot, not to future frames.
18#[derive(Debug, Clone, Copy, PartialEq, Eq)]
19pub enum ScreenDraw {
20    /// A contiguous run of rectangles, lines, circles and paths, batched together.
21    Primitives {
22        /// Snapshot-local geometry-run index (same namespace as rectangle runs).
23        run: usize,
24    },
25    /// One contiguous subsequence of sorted screen rectangles.
26    Rectangles {
27        /// Snapshot-local rectangle-run index.
28        run: usize,
29    },
30    /// One registered image placed between rectangle runs or other images.
31    Image {
32        /// Index into the snapshot's resolved image list.
33        index: usize,
34    },
35    /// One prepared screen label, sharing mixed painter order with other kinds.
36    #[cfg(feature = "headless-text")]
37    Text {
38        /// Index into the snapshot's resolved text list.
39        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            // Rejected repartitions must not retain new large prefix runs
62            // beside untouched large tails from earlier failed attempts.
63            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            // Keep the established single-scene path and do not build duplicate
73            // rectangle runs for applications that have not enabled images.
74            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        // Replacing a scene whenever its run length changes prevents each slot
194        // retaining its historical largest partition. The command cap bounds
195        // content, not allocator slack; Engine still enforces Scene byte caps.
196        // The aggregate full ScreenScene already validated total limits.
197        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            // Construction is empty; dropping the previous scene releases its
222            // command storage before the changed partition is populated.
223            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}