1use 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 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 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 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 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 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 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 #[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 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 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 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 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 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 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 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}