Skip to main content

sim_engine/renderer/
scenes.rs

1//! Ordinary and prepared scene drawing through the shared geometry pipeline.
2
3use super::{
4    Arc, Camera2d, CameraUniform, Color, Duration, GeometryExtents, GeometryValidationCache,
5    GeometryValidationSource, Instant, LogicalViewport, LogicalViewportRegion, PhysicalPerLogical,
6    PreparedDrawBatch, PreparedScene, PreparedSceneError, PreparedSceneRenderError,
7    PreparedScreenScene, RenderReport, RenderStatus, RenderTarget2d, RenderTargetError,
8    RenderTargetLoad, RendererFrameError, RendererSurfaceStatus, Scene, ScissorRect, ScreenScene,
9    TessellationStats, Vec2, Vertex, WgpuRenderer, buffer_capacity_fits, create_vertex_buffer,
10    dynamic_vertex_capacity, geometry_is_safe_for, geometry_is_safe_for_cached,
11    logical_viewport_scissor, offset_scissor, premultiplied_wgpu_color, prepare_scene_resources,
12    prepared_scene_belongs_to, render_report, restore_prepared_scene_resources,
13    scene_estimate_fits_streaming_device, screen_camera, screen_clip_to_scissor, tessellate_scene,
14};
15
16impl WgpuRenderer {
17    /// Draws a scene using the supplied camera.
18    ///
19    /// Scene positions and sizes are in world units unless a style explicitly
20    /// says logical screen pixels. The renderer converts world coordinates to
21    /// logical screen coordinates through [`Camera2d`], then to normalized device
22    /// coordinates for `wgpu`. Scissor rectangles are converted to physical
23    /// surface pixels at the final backend boundary.
24    pub fn render(
25        &mut self,
26        scene: &Scene,
27        camera: &Camera2d,
28    ) -> Result<RenderStatus, RendererFrameError> {
29        self.render_with_metrics(scene, camera)
30            .map(RenderReport::status)
31    }
32
33    /// Draws fixed logical-screen geometry independently of any world camera.
34    pub fn render_screen_scene(
35        &mut self,
36        scene: &ScreenScene,
37    ) -> Result<RenderStatus, RendererFrameError> {
38        self.render_screen_scene_with_metrics(scene)
39            .map(RenderReport::status)
40    }
41
42    /// Draws fixed logical-screen geometry and returns CPU-side stage timings.
43    pub fn render_screen_scene_with_metrics(
44        &mut self,
45        scene: &ScreenScene,
46    ) -> Result<RenderReport, RendererFrameError> {
47        let viewport = LogicalViewport::new(self.logical_size().0, self.logical_size().1)
48            .map_err(|_| RendererFrameError::InvalidGeometryTransform)?;
49        let camera =
50            screen_camera(viewport).map_err(|_| RendererFrameError::InvalidGeometryTransform)?;
51        self.render_with_metrics(scene.as_scene(), &camera)
52    }
53
54    /// Draws a scene and returns a CPU-side timing breakdown.
55    ///
56    /// Metrics separate tessellation, buffer upload, surface acquisition, and
57    /// encode/submit/present dispatch. They do not measure GPU completion or the
58    /// monitor scanout timestamp. Use this for diagnostics; [`WgpuRenderer::render`]
59    /// is the simpler equivalent when stage timings are not needed.
60    pub fn render_with_metrics(
61        &mut self,
62        scene: &Scene,
63        camera: &Camera2d,
64    ) -> Result<RenderReport, RendererFrameError> {
65        self.render_with_metrics_in_region(scene, camera, None)
66    }
67
68    /// Draws a world scene through a camera into one bounded logical viewport.
69    ///
70    /// Scene-local clips are interpreted relative to the viewport and are
71    /// intersected with its physical bounds. The surface outside the viewport
72    /// is cleared but receives no scene geometry.
73    pub fn render_scene_in_viewport(
74        &mut self,
75        scene: &Scene,
76        camera: &Camera2d,
77        viewport: LogicalViewportRegion,
78    ) -> Result<RenderStatus, RendererFrameError> {
79        self.render_scene_in_viewport_with_metrics(scene, camera, viewport)
80            .map(RenderReport::status)
81    }
82
83    /// Draws one bounded scene viewport and returns CPU-side stage timings.
84    pub fn render_scene_in_viewport_with_metrics(
85        &mut self,
86        scene: &Scene,
87        camera: &Camera2d,
88        viewport: LogicalViewportRegion,
89    ) -> Result<RenderReport, RendererFrameError> {
90        self.render_with_metrics_in_region(scene, camera, Some(viewport))
91    }
92
93    /// Renders an ordinary world scene into an offscreen target.
94    ///
95    /// Target dimensions are physical texels. `pixel_scale` defines their
96    /// logical viewport density independently of window DPI. Scene-local clips
97    /// are relative to `viewport`, or to the complete logical target when no
98    /// region is supplied. `load` explicitly controls preservation or clearing.
99    #[allow(clippy::too_many_arguments)]
100    pub fn render_scene_to_target(
101        &mut self,
102        target: &RenderTarget2d,
103        scene: &Scene,
104        camera: &Camera2d,
105        pixel_scale: PhysicalPerLogical,
106        viewport: Option<LogicalViewportRegion>,
107        load: RenderTargetLoad,
108    ) -> Result<RenderReport, RenderTargetError> {
109        self.validate_render_target(target)?;
110        if let RenderTargetLoad::Clear(color) = load
111            && !color.is_normalized()
112        {
113            return Err(RenderTargetError::InvalidBackground);
114        }
115
116        let frame_started_at = Instant::now();
117        let scale = pixel_scale.get();
118        let target_viewport = LogicalViewport::new(
119            target.width() as f32 / scale,
120            target.height() as f32 / scale,
121        )
122        .map_err(|_| RenderTargetError::Frame(RendererFrameError::InvalidViewport))?;
123        let (local_viewport, origin) = match viewport {
124            Some(region) => (region.viewport(), region.origin().to_vec2()),
125            None => (target_viewport, Vec2::ZERO),
126        };
127        let max = origin + local_viewport.size();
128        if !max.is_finite()
129            || origin.x < 0.0
130            || origin.y < 0.0
131            || max.x > target_viewport.width()
132            || max.y > target_viewport.height()
133        {
134            return Err(RenderTargetError::Frame(
135                RendererFrameError::InvalidViewport,
136            ));
137        }
138        let target_scissor = logical_viewport_scissor(
139            origin,
140            local_viewport,
141            scale,
142            target.width(),
143            target.height(),
144        )
145        .ok_or(RenderTargetError::Frame(
146            RendererFrameError::InvalidViewport,
147        ))?;
148        let camera_uniform =
149            CameraUniform::new_in_region(*camera, local_viewport, origin, target_viewport).ok_or(
150                RenderTargetError::Frame(RendererFrameError::InvalidGeometryTransform),
151            )?;
152
153        let tessellation_started_at = Instant::now();
154        if !scene_estimate_fits_streaming_device(scene, &self.device, 0, self.vertex_capacity) {
155            return Err(RenderTargetError::Frame(
156                RendererFrameError::GeometryCapacityTooLarge,
157            ));
158        }
159        self.vertices.clear();
160        self.draw_batches.clear();
161        let tessellation_stats =
162            tessellate_scene(scene, &mut self.vertices, &mut self.draw_batches)
163                .map_err(RendererFrameError::from)
164                .map_err(RenderTargetError::Frame)?;
165        let tessellation = tessellation_started_at.elapsed();
166
167        let extents = GeometryExtents::from_vertices(&self.vertices);
168        if !geometry_is_safe_for(
169            extents,
170            GeometryValidationSource::Tessellated(&self.vertices),
171            camera_uniform,
172        ) {
173            return Err(RenderTargetError::Frame(
174                RendererFrameError::InvalidGeometryTransform,
175            ));
176        }
177        let upload_started_at = Instant::now();
178        self.ensure_vertex_capacity(self.vertices.len())
179            .map_err(RenderTargetError::Frame)?;
180        if !self.vertices.is_empty() {
181            self.queue
182                .write_buffer(&self.vertex_buffer, 0, bytemuck::cast_slice(&self.vertices));
183        }
184        let upload = upload_started_at.elapsed();
185        let uniform_started_at = Instant::now();
186        self.queue.write_buffer(
187            &self.camera_uniform_buffer,
188            0,
189            bytemuck::bytes_of(&camera_uniform),
190        );
191        let camera_uniform_upload = uniform_started_at.elapsed();
192
193        let encode_started_at = Instant::now();
194        let mut encoder = self
195            .device
196            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
197                label: Some("sim-engine scene target encoder"),
198            });
199        {
200            let load = match load {
201                RenderTargetLoad::Load => wgpu::LoadOp::Load,
202                RenderTargetLoad::Clear(color) => {
203                    wgpu::LoadOp::Clear(premultiplied_wgpu_color(color))
204                }
205            };
206            let color_attachment = wgpu::RenderPassColorAttachment {
207                view: &target.view,
208                depth_slice: None,
209                resolve_target: None,
210                ops: wgpu::Operations {
211                    load,
212                    store: wgpu::StoreOp::Store,
213                },
214            };
215            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
216                label: Some("sim-engine scene target pass"),
217                color_attachments: &[Some(color_attachment)],
218                depth_stencil_attachment: None,
219                timestamp_writes: None,
220                occlusion_query_set: None,
221                multiview_mask: None,
222            });
223            if !self.vertices.is_empty() {
224                pass.set_pipeline(&self.target_pipeline);
225                pass.set_bind_group(0, &self.camera_bind_group, &[]);
226                pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
227                for batch in &self.draw_batches {
228                    let scissor = match batch.screen_clip {
229                        Some(clip) => {
230                            let Some(local) = screen_clip_to_scissor(clip, local_viewport, scale)
231                            else {
232                                continue;
233                            };
234                            let Some(scissor) = offset_scissor(local, target_scissor) else {
235                                continue;
236                            };
237                            scissor
238                        }
239                        None => target_scissor,
240                    };
241                    pass.set_scissor_rect(scissor.x, scissor.y, scissor.width, scissor.height);
242                    pass.draw(batch.vertex_range.clone(), 0..1);
243                }
244            }
245        }
246        self.queue.submit([encoder.finish()]);
247        let encode = encode_started_at.elapsed();
248
249        Ok(render_report(
250            RenderStatus::Drawn,
251            tessellation,
252            upload,
253            camera_uniform_upload,
254            Duration::ZERO,
255            encode,
256            frame_started_at.elapsed(),
257            false,
258            true,
259            tessellation_stats,
260        ))
261    }
262
263    fn render_with_metrics_in_region(
264        &mut self,
265        scene: &Scene,
266        camera: &Camera2d,
267        viewport: Option<LogicalViewportRegion>,
268    ) -> Result<RenderReport, RendererFrameError> {
269        let frame_started_at = Instant::now();
270        let (_, _, camera_uniform) = self.surface_geometry_context(*camera, viewport)?;
271        let tessellation_started_at = Instant::now();
272        if !scene_estimate_fits_streaming_device(scene, &self.device, 0, self.vertex_capacity) {
273            return Err(RendererFrameError::GeometryCapacityTooLarge);
274        }
275        self.vertices.clear();
276        self.draw_batches.clear();
277        let tessellation_stats =
278            tessellate_scene(scene, &mut self.vertices, &mut self.draw_batches)?;
279        let tessellation = tessellation_started_at.elapsed();
280
281        let geometry_extents = GeometryExtents::from_vertices(&self.vertices);
282        if !geometry_is_safe_for(
283            geometry_extents,
284            GeometryValidationSource::Tessellated(&self.vertices),
285            camera_uniform,
286        ) {
287            return Err(RendererFrameError::InvalidGeometryTransform);
288        }
289
290        let upload_started_at = Instant::now();
291        self.ensure_vertex_capacity(self.vertices.len())?;
292        let upload = upload_started_at.elapsed();
293
294        let vertex_buffer = Arc::clone(&self.vertex_buffer);
295        let draw_batches = std::mem::take(&mut self.draw_batches);
296        let vertices = std::mem::take(&mut self.vertices);
297        let result = self.draw_geometry(
298            scene.background(),
299            &vertex_buffer,
300            vertices.len(),
301            geometry_extents,
302            GeometryValidationSource::Tessellated(&vertices),
303            None,
304            &draw_batches,
305            *camera,
306            tessellation,
307            upload,
308            false,
309            true,
310            false,
311            Some(&vertices),
312            tessellation_stats,
313            frame_started_at,
314            viewport,
315        );
316        self.vertices = vertices;
317        self.draw_batches = draw_batches;
318        result
319    }
320
321    /// Tessellates a scene once and uploads immutable geometry to a dedicated GPU buffer.
322    ///
323    /// Preparing is appropriate for geometry that will be drawn repeatedly while
324    /// only the camera or target dimensions change. Any shape, style, gradient,
325    /// ordering, or clipping change requires preparing a replacement scene.
326    pub fn prepare_scene(&self, scene: &Scene) -> Result<PreparedScene, PreparedSceneError> {
327        prepare_scene_resources(
328            &self.device,
329            &self.queue,
330            Arc::clone(&self.renderer_identity),
331            scene,
332        )
333    }
334
335    /// Tessellates fixed logical-screen geometry once for repeated composition.
336    pub fn prepare_screen_scene(
337        &self,
338        scene: &ScreenScene,
339    ) -> Result<PreparedScreenScene, PreparedSceneError> {
340        self.prepare_scene(scene.as_scene())
341            .map(|scene| PreparedScreenScene { scene })
342    }
343
344    /// Restores prepared logical-screen geometry on a recreated renderer.
345    pub fn restore_prepared_screen_scene(
346        &self,
347        source: &PreparedScreenScene,
348    ) -> Result<PreparedScreenScene, PreparedSceneError> {
349        self.restore_prepared_scene(&source.scene)
350            .map(|scene| PreparedScreenScene { scene })
351    }
352
353    /// Recreates prepared GPU resources on this renderer from a retained CPU snapshot.
354    ///
355    /// This supports renderer recreation after device loss without requiring the
356    /// original high-level [`Scene`]. The returned snapshot belongs to this renderer.
357    pub fn restore_prepared_scene(
358        &self,
359        source: &PreparedScene,
360    ) -> Result<PreparedScene, PreparedSceneError> {
361        restore_prepared_scene_resources(
362            &self.device,
363            &self.queue,
364            Arc::clone(&self.renderer_identity),
365            source,
366        )
367    }
368
369    /// Draws geometry previously uploaded by [`WgpuRenderer::prepare_scene`].
370    ///
371    /// Camera and viewport changes are applied by the vertex shader and do not
372    /// rebuild or re-upload the prepared geometry.
373    pub fn render_prepared(
374        &mut self,
375        scene: &PreparedScene,
376        camera: &Camera2d,
377    ) -> Result<RenderStatus, PreparedSceneRenderError> {
378        self.render_prepared_with_metrics(scene, camera)
379            .map(RenderReport::status)
380    }
381
382    /// Draws prepared logical-screen geometry independently of a world camera.
383    ///
384    /// The prepared resource must have been built from a [`ScreenScene`]. The
385    /// renderer cannot infer the original coordinate space from raw prepared
386    /// vertices, so passing world-space geometry is a caller contract error.
387    pub fn render_prepared_screen_scene(
388        &mut self,
389        scene: &PreparedScreenScene,
390    ) -> Result<RenderStatus, PreparedSceneRenderError> {
391        let (width, height) = self.logical_size();
392        let viewport = LogicalViewport::new(width, height).map_err(|_| {
393            PreparedSceneRenderError::Frame(RendererFrameError::InvalidGeometryTransform)
394        })?;
395        let camera = screen_camera(viewport).map_err(|_| {
396            PreparedSceneRenderError::Frame(RendererFrameError::InvalidGeometryTransform)
397        })?;
398        self.render_prepared(&scene.scene, &camera)
399    }
400
401    /// Draws prepared geometry and reports per-frame CPU timing.
402    ///
403    /// Tessellation and geometry upload durations are zero because both happened
404    /// in [`WgpuRenderer::prepare_scene`]. The camera uniform is still updated
405    /// once per frame.
406    pub fn render_prepared_with_metrics(
407        &mut self,
408        scene: &PreparedScene,
409        camera: &Camera2d,
410    ) -> Result<RenderReport, PreparedSceneRenderError> {
411        if !prepared_scene_belongs_to(&self.renderer_identity, &scene.renderer_identity) {
412            return Err(PreparedSceneRenderError::RendererMismatch);
413        }
414
415        self.draw_geometry(
416            scene.background,
417            &scene.vertex_buffer,
418            scene.vertex_count,
419            scene.geometry_extents,
420            GeometryValidationSource::Tessellated(&scene.vertices),
421            Some(&scene.geometry_validation_cache),
422            &scene.draw_batches,
423            *camera,
424            Duration::ZERO,
425            Duration::ZERO,
426            true,
427            false,
428            false,
429            None,
430            scene.tessellation,
431            Instant::now(),
432            None,
433        )
434        .map_err(PreparedSceneRenderError::Frame)
435    }
436
437    fn surface_geometry_context(
438        &self,
439        camera: Camera2d,
440        viewport_region: Option<LogicalViewportRegion>,
441    ) -> Result<(LogicalViewport, ScissorRect, CameraUniform), RendererFrameError> {
442        let (logical_width, logical_height) = self.logical_size();
443        let target_viewport = LogicalViewport::new(logical_width, logical_height)
444            .map_err(|_| RendererFrameError::InvalidGeometryTransform)?;
445        let (viewport, viewport_origin) = match viewport_region {
446            Some(region) => (region.viewport(), region.origin().to_vec2()),
447            None => (target_viewport, Vec2::ZERO),
448        };
449        let viewport_max = viewport_origin + viewport.size();
450        if !viewport_origin.is_finite()
451            || !viewport_max.is_finite()
452            || viewport_origin.x < 0.0
453            || viewport_origin.y < 0.0
454            || viewport_max.x > target_viewport.width()
455            || viewport_max.y > target_viewport.height()
456        {
457            return Err(RendererFrameError::InvalidViewport);
458        }
459        let viewport_scissor = logical_viewport_scissor(
460            viewport_origin,
461            viewport,
462            self.scale_factor as f32,
463            self.config.width,
464            self.config.height,
465        )
466        .ok_or(RendererFrameError::InvalidViewport)?;
467        let camera_uniform =
468            CameraUniform::new_in_region(camera, viewport, viewport_origin, target_viewport)
469                .ok_or(RendererFrameError::InvalidGeometryTransform)?;
470        Ok((viewport, viewport_scissor, camera_uniform))
471    }
472
473    #[allow(clippy::too_many_arguments)]
474    pub(super) fn draw_geometry(
475        &mut self,
476        background: Color,
477        vertex_buffer: &wgpu::Buffer,
478        vertex_count: usize,
479        geometry_extents: GeometryExtents,
480        geometry_validation: GeometryValidationSource<'_>,
481        geometry_validation_cache: Option<&GeometryValidationCache>,
482        draw_batches: &[PreparedDrawBatch],
483        camera: Camera2d,
484        tessellation: Duration,
485        mut upload: Duration,
486        geometry_reused: bool,
487        geometry_streamed: bool,
488        uses_dynamic_pipeline: bool,
489        pending_vertex_upload: Option<&[Vertex]>,
490        tessellation_stats: TessellationStats,
491        frame_started_at: Instant,
492        viewport_region: Option<LogicalViewportRegion>,
493    ) -> Result<RenderReport, RendererFrameError> {
494        let (viewport, viewport_scissor, camera_uniform) =
495            self.surface_geometry_context(camera, viewport_region)?;
496        if !geometry_is_safe_for_cached(
497            geometry_validation_cache,
498            geometry_extents,
499            geometry_validation,
500            camera_uniform,
501        ) {
502            return Err(RendererFrameError::InvalidGeometryTransform);
503        }
504
505        let surface_acquire_started_at = Instant::now();
506        let surface_texture = match self.surface.get_current_texture() {
507            wgpu::CurrentSurfaceTexture::Success(texture)
508            | wgpu::CurrentSurfaceTexture::Suboptimal(texture) => texture,
509            wgpu::CurrentSurfaceTexture::Timeout => {
510                return Ok(render_report(
511                    RenderStatus::Skipped(RendererSurfaceStatus::Timeout),
512                    tessellation,
513                    upload,
514                    Duration::ZERO,
515                    surface_acquire_started_at.elapsed(),
516                    Duration::ZERO,
517                    frame_started_at.elapsed(),
518                    geometry_reused,
519                    geometry_streamed,
520                    tessellation_stats,
521                ));
522            }
523            wgpu::CurrentSurfaceTexture::Occluded => {
524                return Ok(render_report(
525                    RenderStatus::Skipped(RendererSurfaceStatus::Occluded),
526                    tessellation,
527                    upload,
528                    Duration::ZERO,
529                    surface_acquire_started_at.elapsed(),
530                    Duration::ZERO,
531                    frame_started_at.elapsed(),
532                    geometry_reused,
533                    geometry_streamed,
534                    tessellation_stats,
535                ));
536            }
537            wgpu::CurrentSurfaceTexture::Outdated => {
538                let _ = self.resize(self.config.width, self.config.height);
539                return Ok(render_report(
540                    RenderStatus::Skipped(RendererSurfaceStatus::Outdated),
541                    tessellation,
542                    upload,
543                    Duration::ZERO,
544                    surface_acquire_started_at.elapsed(),
545                    Duration::ZERO,
546                    frame_started_at.elapsed(),
547                    geometry_reused,
548                    geometry_streamed,
549                    tessellation_stats,
550                ));
551            }
552            wgpu::CurrentSurfaceTexture::Lost => {
553                return Err(RendererFrameError::Surface(RendererSurfaceStatus::Lost));
554            }
555            wgpu::CurrentSurfaceTexture::Validation => {
556                return Err(RendererFrameError::Surface(
557                    RendererSurfaceStatus::Validation,
558                ));
559            }
560        };
561        let surface_acquire = surface_acquire_started_at.elapsed();
562        let vertex_upload_started_at = Instant::now();
563        if let Some(vertices) = pending_vertex_upload
564            && !vertices.is_empty()
565        {
566            self.queue
567                .write_buffer(vertex_buffer, 0, bytemuck::cast_slice(vertices));
568        }
569        upload = upload.saturating_add(vertex_upload_started_at.elapsed());
570        let camera_uniform_upload_started_at = Instant::now();
571        self.queue.write_buffer(
572            &self.camera_uniform_buffer,
573            0,
574            bytemuck::bytes_of(&camera_uniform),
575        );
576        let camera_uniform_upload = camera_uniform_upload_started_at.elapsed();
577
578        let encode_submit_present_started_at = Instant::now();
579        let surface_view = surface_texture
580            .texture
581            .create_view(&wgpu::TextureViewDescriptor::default());
582        let (view, resolve_target) = match &self.multisample_target {
583            Some(target) => (&target.view, Some(&surface_view)),
584            None => (&surface_view, None),
585        };
586
587        let mut encoder = self
588            .device
589            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
590                label: Some("sim-engine render encoder"),
591            });
592
593        {
594            let color_attachment = wgpu::RenderPassColorAttachment {
595                view,
596                depth_slice: None,
597                resolve_target,
598                ops: wgpu::Operations {
599                    load: wgpu::LoadOp::Clear(background.to_wgpu()),
600                    store: wgpu::StoreOp::Store,
601                },
602            };
603            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
604                label: Some("sim-engine render pass"),
605                color_attachments: &[Some(color_attachment)],
606                depth_stencil_attachment: None,
607                timestamp_writes: None,
608                occlusion_query_set: None,
609                multiview_mask: None,
610            });
611
612            if vertex_count > 0 {
613                let pipeline = if uses_dynamic_pipeline {
614                    &self.dynamic_pipeline
615                } else {
616                    &self.pipeline
617                };
618                pass.set_pipeline(pipeline);
619                pass.set_bind_group(0, &self.camera_bind_group, &[]);
620                pass.set_vertex_buffer(0, vertex_buffer.slice(..));
621                for batch in draw_batches {
622                    let scissor = match batch.screen_clip {
623                        Some(screen_clip) => {
624                            let Some(local_scissor) = screen_clip_to_scissor(
625                                screen_clip,
626                                viewport,
627                                self.scale_factor as f32,
628                            ) else {
629                                continue;
630                            };
631                            let Some(scissor) = offset_scissor(local_scissor, viewport_scissor)
632                            else {
633                                continue;
634                            };
635                            scissor
636                        }
637                        None => viewport_scissor,
638                    };
639                    pass.set_scissor_rect(scissor.x, scissor.y, scissor.width, scissor.height);
640                    pass.draw(batch.vertex_range.clone(), 0..1);
641                }
642            }
643        }
644
645        self.queue.submit([encoder.finish()]);
646        self.notify_before_present();
647        self.queue.present(surface_texture);
648        let encode_submit_present = encode_submit_present_started_at.elapsed();
649
650        Ok(render_report(
651            RenderStatus::Drawn,
652            tessellation,
653            upload,
654            camera_uniform_upload,
655            surface_acquire,
656            encode_submit_present,
657            frame_started_at.elapsed(),
658            geometry_reused,
659            geometry_streamed,
660            tessellation_stats,
661        ))
662    }
663
664    pub(super) fn ensure_vertex_capacity(
665        &mut self,
666        vertex_count: usize,
667    ) -> Result<(), RendererFrameError> {
668        if vertex_count <= self.vertex_capacity {
669            return Ok(());
670        }
671
672        self.vertex_capacity = dynamic_vertex_capacity(vertex_count)
673            .filter(|capacity| buffer_capacity_fits::<Vertex>(&self.device, *capacity))
674            .ok_or(RendererFrameError::GeometryCapacityTooLarge)?;
675        self.vertex_buffer = Arc::new(create_vertex_buffer(&self.device, self.vertex_capacity));
676        Ok(())
677    }
678}