Skip to main content

sim_engine/renderer/frame/
primitives.rs

1//! Compact retained screen primitives under the ordinary frame's ordering/budget.
2
3use std::time::Instant;
4
5use super::{
6    FrameComposer, FrameComposerError, FrameItem, FramePassOptions, FrameSourceKind,
7    FrameSourceStatistics, FrameStatistics, ReadyGeometry, ReadyItem, ReadySource,
8    ResolvedViewport, RetainedResourceAccounting, add_tessellation_stats, retained_key,
9};
10use crate::renderer::{
11    CameraUniform, LogicalViewport, PreparedDrawBatch, RendererFrameError,
12    RendererPreparationMetrics, ScreenPrimitiveBatch2d, TessellationStats,
13    prepared_scene_belongs_to, screen_camera,
14};
15
16impl<'frame> FrameComposer<'frame> {
17    /// Adds compact retained solid circles, round lines and rectangles in local
18    /// logical screen pixels. World-camera motion does not affect this source.
19    ///
20    /// Input primitive order and captured logical clips are preserved. Adjacent
21    /// equal clips share an instanced draw. The batch is one frame item: split
22    /// it where other sources must interleave. One six-vertex quad is referenced
23    /// per primitive; analytic coverage replaces polygonal round boundaries.
24    /// Resource updates happen before composition and have their own reports.
25    /// This path is classified as prepared geometry in source statistics.
26    pub fn draw_screen_primitive_batch(
27        &mut self,
28        batch: &'frame ScreenPrimitiveBatch2d,
29        options: FramePassOptions,
30    ) -> Result<(), FrameComposerError> {
31        if !prepared_scene_belongs_to(&self.renderer.renderer_identity, &batch.renderer_identity) {
32            return Err(FrameComposerError::RendererMismatch {
33                source: FrameSourceKind::PreparedScene,
34            });
35        }
36        self.push_accounted_item(
37            &[
38                RetainedResourceAccounting::new(
39                    retained_key(batch, 36),
40                    batch.retained_cpu_bytes(),
41                    0,
42                    0,
43                ),
44                RetainedResourceAccounting::new(
45                    retained_key(&batch.instance_buffer, 37),
46                    0,
47                    batch.gpu_buffer_bytes(),
48                    0,
49                ),
50            ],
51            FrameStatistics {
52                pass_count: 1,
53                command_count: batch.primitive_count(),
54                vertex_count: batch.vertex_count(),
55                reused_vertex_count: batch.vertex_count(),
56                upload_bytes: std::mem::size_of::<CameraUniform>(),
57                draw_calls: batch.draw_batches.len(),
58                source_counts: FrameSourceStatistics::single(FrameSourceKind::PreparedScene),
59                ..FrameStatistics::default()
60            },
61            FrameItem::ScreenPrimitives {
62                batch,
63                options,
64                insertion: self.next_insertion,
65            },
66        )
67    }
68}
69
70pub(super) fn validate(
71    batch: &ScreenPrimitiveBatch2d,
72    viewport: ResolvedViewport,
73    target: LogicalViewport,
74    scale_factor: f32,
75    preparation: &mut RendererPreparationMetrics,
76) -> Result<CameraUniform, FrameComposerError> {
77    let camera = screen_camera(viewport.viewport)
78        .map_err(|_| RendererFrameError::InvalidGeometryTransform)?;
79    let uniform = CameraUniform::new_in_region(camera, viewport.viewport, viewport.origin, target)
80        .ok_or(RendererFrameError::InvalidGeometryTransform)?;
81    let started = Instant::now();
82    let safe = batch.is_safe_for(uniform, scale_factor);
83    preparation.geometry_validation += started.elapsed();
84    if !safe {
85        return Err(RendererFrameError::InvalidGeometryTransform.into());
86    }
87    Ok(uniform)
88}
89
90#[allow(clippy::too_many_arguments)]
91pub(super) fn prepare<'frame>(
92    batch: &'frame ScreenPrimitiveBatch2d,
93    viewport: ResolvedViewport,
94    target: LogicalViewport,
95    scale_factor: f32,
96    preparation: &mut RendererPreparationMetrics,
97    ready: &mut Vec<ReadyItem<'frame>>,
98    statistics: &mut FrameStatistics,
99    aggregate: &mut TessellationStats,
100    mut batches: Vec<PreparedDrawBatch>,
101) -> Result<(), FrameComposerError> {
102    let camera_uniform = validate(batch, viewport, target, scale_factor, preparation)?;
103    batches.try_reserve(batch.draw_batches.len()).map_err(|_| {
104        FrameComposerError::AllocationFailed {
105            requested_bytes: batch
106                .draw_batches
107                .len()
108                .saturating_mul(std::mem::size_of::<PreparedDrawBatch>()),
109        }
110    })?;
111    batches.extend_from_slice(&batch.draw_batches);
112    *statistics = statistics.adding(FrameStatistics {
113        pass_count: 1,
114        command_count: batch.primitive_count(),
115        vertex_count: batch.vertex_count(),
116        reused_vertex_count: batch.vertex_count(),
117        upload_bytes: std::mem::size_of::<CameraUniform>(),
118        draw_calls: batches.len(),
119        ..FrameStatistics::default()
120    });
121    add_tessellation_stats(aggregate, batch.tessellation_stats());
122    ready.push(ReadyItem::Geometry(ReadyGeometry {
123        source: ReadySource::ScreenPrimitives(&batch.instance_buffer),
124        vertex_count: batch.vertex_count(),
125        batches,
126        camera_uniform,
127        viewport,
128    }));
129    Ok(())
130}