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_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 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 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 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 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 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 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 #[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 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 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 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 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 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 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 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}