sim-logic 0.1.0

A code-first application and logic layer for Sim;Engine
Documentation
//! Exact mixed screen ordering and bounded, reusable geometry runs.

use std::mem::size_of;

use sim_engine::{Color, SceneBudget, ScreenScene};

use super::{
    super::{ExtractionError, compare_visual_order},
    ResolvedScreenPrimitive, ScreenExtractionBuffer,
};

/// One ordered screen source, after all world content.
///
/// Images index `ExtractedFrame::resolved_screen_images`; geometry runs are
/// inspected with `ExtractedFrame::screen_primitive_run_records`. The older
/// `screen_rectangle_run_records` selects only rectangles from a run. Indices
/// belong only to their containing snapshot, not to future frames.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ScreenDraw {
    /// A contiguous run of rectangles, lines, circles and paths, batched together.
    Primitives {
        /// Snapshot-local geometry-run index (same namespace as rectangle runs).
        run: usize,
    },
    /// One contiguous subsequence of sorted screen rectangles.
    Rectangles {
        /// Snapshot-local rectangle-run index.
        run: usize,
    },
    /// One registered image placed between rectangle runs or other images.
    Image {
        /// Index into the snapshot's resolved image list.
        index: usize,
    },
    /// One prepared screen label, sharing mixed painter order with other kinds.
    #[cfg(feature = "headless-text")]
    Text {
        /// Index into the snapshot's resolved text list.
        index: usize,
    },
}

#[derive(Clone, Copy)]
enum NonRectangleKind {
    Image,
    #[cfg(feature = "headless-text")]
    Text,
}

pub(super) struct RectangleRun {
    pub(super) start: usize,
    pub(super) end: usize,
    pub(super) scene: ScreenScene,
    pub(super) records: Vec<ResolvedScreenPrimitive>,
}

impl ScreenExtractionBuffer {
    pub(super) fn compose(&mut self, budget: SceneBudget) -> Result<(), ExtractionError> {
        let result = self.compose_inner(budget);
        if result.is_err() {
            // Rejected repartitions must not retain new large prefix runs
            // beside untouched large tails from earlier failed attempts.
            self.runs.clear();
            self.draws.clear();
        }
        result
    }

    fn compose_inner(&mut self, budget: SceneBudget) -> Result<(), ExtractionError> {
        self.draws.clear();
        if !self.has_non_rectangles() {
            // Keep the established single-scene path and do not build duplicate
            // rectangle runs for applications that have not enabled images.
            self.runs.clear();
            if self.geometry_len() != 0 {
                self.push_draw(self.geometry_draw(0))?;
            }
            return Ok(());
        }

        let mut rectangle = 0;
        let mut image = 0;
        #[cfg(feature = "headless-text")]
        let mut text = 0;
        let mut run_start = 0;
        let mut run_count = 0;
        loop {
            let next = self.images.get(image).map(|image| {
                (
                    NonRectangleKind::Image,
                    image.layer(),
                    image.draw_order_depth(),
                    image.source(),
                )
            });
            #[cfg(feature = "headless-text")]
            let next = match (next, self.texts.get(text)) {
                (Some(image), Some(text))
                    if !compare_visual_order(
                        image.1,
                        image.2,
                        image.3,
                        text.layer(),
                        text.draw_order_depth(),
                        text.source(),
                    )
                    .is_gt() =>
                {
                    Some(image)
                }
                (_, Some(text)) => Some((
                    NonRectangleKind::Text,
                    text.layer(),
                    text.draw_order_depth(),
                    text.source(),
                )),
                (image, None) => image,
            };
            let take_rectangle = match (self.geometry(rectangle), next) {
                (Some(left), Some(right)) => !compare_visual_order(
                    left.layer(),
                    left.draw_order_depth(),
                    left.source(),
                    right.1,
                    right.2,
                    right.3,
                )
                .is_gt(),
                (Some(_), None) => true,
                (None, Some(_)) => false,
                (None, None) => break,
            };
            if take_rectangle {
                rectangle += 1;
            } else if let Some((kind, _, _, _)) = next {
                if run_start != rectangle {
                    self.prepare_run(run_count, run_start, rectangle, budget)?;
                    self.push_draw(self.geometry_draw(run_count))?;
                    run_count += 1;
                }
                match kind {
                    NonRectangleKind::Image => {
                        self.push_draw(ScreenDraw::Image { index: image })?;
                        image += 1;
                    }
                    #[cfg(feature = "headless-text")]
                    NonRectangleKind::Text => {
                        self.push_draw(ScreenDraw::Text { index: text })?;
                        text += 1;
                    }
                }
                run_start = rectangle;
            }
        }
        if run_start != rectangle {
            self.prepare_run(run_count, run_start, rectangle, budget)?;
            self.push_draw(self.geometry_draw(run_count))?;
            run_count += 1;
        }
        self.runs.truncate(run_count);
        Ok(())
    }

    fn push_draw(&mut self, draw: ScreenDraw) -> Result<(), ExtractionError> {
        self.draws
            .try_reserve(1)
            .map_err(|_| ExtractionError::AllocationFailed {
                requested_bytes: size_of::<ScreenDraw>(),
            })?;
        self.draws.push(draw);
        Ok(())
    }

    fn prepare_run(
        &mut self,
        index: usize,
        start: usize,
        end: usize,
        budget: SceneBudget,
    ) -> Result<(), ExtractionError> {
        let count = end - start;
        if self.runs.get(index).is_some_and(|run| {
            run.records
                .iter()
                .cloned()
                .eq((start..end).filter_map(|position| self.geometry(position)))
        }) {
            self.runs[index].start = start;
            self.runs[index].end = end;
            self.updates.reused_runs += 1;
            return Ok(());
        }
        // Replacing a scene whenever its run length changes prevents each slot
        // retaining its historical largest partition. The command cap bounds
        // content, not allocator slack; Engine still enforces Scene byte caps.
        // The aggregate full ScreenScene already validated total limits.
        let run_budget = SceneBudget::new(
            count,
            budget.max_points(),
            budget.max_tessellated_vertices(),
            budget.max_retained_bytes(),
            budget.max_allocation_bytes(),
            budget.max_upload_bytes(),
            budget.max_draw_batches(),
        );
        if index == self.runs.len() {
            self.runs
                .try_reserve(1)
                .map_err(|_| ExtractionError::AllocationFailed {
                    requested_bytes: size_of::<RectangleRun>(),
                })?;
            let scene = ScreenScene::with_budget(Color::TRANSPARENT, run_budget)
                .map_err(ExtractionError::ScreenScene)?;
            self.runs.push(RectangleRun {
                start,
                end,
                scene,
                records: Vec::new(),
            });
        } else if self.runs[index].end - self.runs[index].start != count {
            // Construction is empty; dropping the previous scene releases its
            // command storage before the changed partition is populated.
            self.runs[index].scene = ScreenScene::with_budget(Color::TRANSPARENT, run_budget)
                .map_err(ExtractionError::ScreenScene)?;
            self.runs[index].records = Vec::new();
        }
        self.runs[index].start = start;
        self.runs[index].end = end;
        self.runs[index].scene.clear();
        self.runs[index].records.clear();
        self.runs[index]
            .records
            .try_reserve_exact(count)
            .map_err(|_| ExtractionError::AllocationFailed {
                requested_bytes: count.saturating_mul(size_of::<ResolvedScreenPrimitive>()),
            })?;
        for position in start..end {
            if let Some(primitive) = self.geometry(position) {
                primitive
                    .append(&mut self.runs[index].scene)
                    .map_err(ExtractionError::ScreenScene)?;
                self.runs[index].records.push(primitive);
            }
        }
        self.updates.rebuilt_runs += 1;
        Ok(())
    }
}