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