diff --git a/Cargo.lock b/Cargo.lock index 0df29720b7..1a47f73717 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6657,9 +6657,9 @@ dependencies = [ [[package]] name = "wgpu-profiler" -version = "0.2.1" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98580e756637420f660385d6ec86e97080b588325daa3326d0229b39307d5aa3" +checksum = "b96b9e4e035cf917ec6172118dbee8c130b1d8a0ac02f1ca0d3898ee90395407" dependencies = [ "futures", "wgpu", diff --git a/voxygen/Cargo.toml b/voxygen/Cargo.toml index b85761738b..0f063895f6 100644 --- a/voxygen/Cargo.toml +++ b/voxygen/Cargo.toml @@ -46,7 +46,7 @@ i18n = {package = "veloren-i18n", path = "i18n"} # Graphics winit = {version = "0.24.0", features = ["serde"]} wgpu = "=0.7.0" -wgpu-profiler = "0.2.1" +wgpu-profiler = "0.3.1" bytemuck = { version="1.4", features=["derive"] } shaderc = "0.6.2" diff --git a/voxygen/src/render/mod.rs b/voxygen/src/render/mod.rs index c6dc1bf601..55f865f82a 100644 --- a/voxygen/src/render/mod.rs +++ b/voxygen/src/render/mod.rs @@ -8,7 +8,6 @@ pub mod mesh; pub mod model; pub mod pipelines; pub mod renderer; -mod scope; pub mod texture; // Reexports diff --git a/voxygen/src/render/renderer/drawer.rs b/voxygen/src/render/renderer/drawer.rs index 61f820d33b..d71ff59c8d 100644 --- a/voxygen/src/render/renderer/drawer.rs +++ b/voxygen/src/render/renderer/drawer.rs @@ -8,13 +8,13 @@ use super::{ clouds, figure, fluid, lod_terrain, particle, postprocess, shadow, skybox, sprite, terrain, ui, ColLights, GlobalsBindGroup, Light, Shadow, }, - scope::{ManualOwningScope, OwningScope, Scope}, }, Renderer, ShadowMap, ShadowMapRenderer, }; use core::{num::NonZeroU32, ops::Range}; use std::sync::Arc; use vek::Aabr; +use wgpu_profiler::scope::{ManualOwningScope, OwningScope, Scope}; // Borrow the fields we need from the renderer so that the GpuProfiler can be // dijointly borrowed mutably @@ -57,7 +57,7 @@ impl<'frame> Drawer<'frame> { }; let mut encoder = - ManualOwningScope::start(&mut renderer.profiler, encoder, borrow.device, "frame"); + ManualOwningScope::start("frame", &mut renderer.profiler, encoder, borrow.device); Self { encoder: Some(encoder), @@ -75,7 +75,7 @@ impl<'frame> Drawer<'frame> { let encoder = self.encoder.as_mut().unwrap(); let device = self.borrow.device; let mut render_pass = - encoder.scoped_render_pass(device, "shadow_pass", &wgpu::RenderPassDescriptor { + encoder.scoped_render_pass("shadow_pass", device, &wgpu::RenderPassDescriptor { label: Some("shadow pass"), color_attachments: &[], depth_stencil_attachment: Some( @@ -106,7 +106,7 @@ impl<'frame> Drawer<'frame> { let encoder = self.encoder.as_mut().unwrap(); let device = self.borrow.device; let mut render_pass = - encoder.scoped_render_pass(device, "first_pass", &wgpu::RenderPassDescriptor { + encoder.scoped_render_pass("first_pass", device, &wgpu::RenderPassDescriptor { label: Some("first pass"), color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor { attachment: &self.borrow.views.tgt_color, @@ -140,7 +140,7 @@ impl<'frame> Drawer<'frame> { let encoder = self.encoder.as_mut().unwrap(); let device = self.borrow.device; let mut render_pass = - encoder.scoped_render_pass(device, "second_pass", &wgpu::RenderPassDescriptor { + encoder.scoped_render_pass("second_pass", device, &wgpu::RenderPassDescriptor { label: Some("second pass (clouds)"), color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor { attachment: &self.borrow.views.tgt_color_pp, @@ -166,7 +166,7 @@ impl<'frame> Drawer<'frame> { let encoder = self.encoder.as_mut().unwrap(); let device = self.borrow.device; let mut render_pass = - encoder.scoped_render_pass(device, "third_pass", &wgpu::RenderPassDescriptor { + encoder.scoped_render_pass("third_pass", device, &wgpu::RenderPassDescriptor { label: Some("third pass (postprocess + ui)"), color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor { attachment: &self.swap_tex.view, @@ -199,7 +199,7 @@ impl<'frame> Drawer<'frame> { .encoder .as_mut() .unwrap() - .scope(device, "point shadows"); + .scope("point shadows", device); const STRIDE: usize = std::mem::size_of::(); let data = bytemuck::cast_slice(matrices); @@ -222,7 +222,7 @@ impl<'frame> Drawer<'frame> { let label = format!("point shadow face-{} pass", face); let mut render_pass = - encoder.scoped_render_pass(device, &label, &wgpu::RenderPassDescriptor { + encoder.scoped_render_pass(&label, device, &wgpu::RenderPassDescriptor { label: Some(&label), color_attachments: &[], depth_stencil_attachment: Some( @@ -269,9 +269,9 @@ impl<'frame> Drawer<'frame> { if let ShadowMap::Enabled(ref shadow_renderer) = self.borrow.shadow.map { let device = self.borrow.device; let encoder = self.encoder.as_mut().unwrap(); - encoder.scoped_render_pass( - device, + let _ = encoder.scoped_render_pass( "clear_directed_shadow", + device, &wgpu::RenderPassDescriptor { label: Some("clear directed shadow pass"), color_attachments: &[], @@ -306,7 +306,7 @@ impl<'frame> Drawer<'frame> { }); let label = format!("clear point shadow face-{} pass", face); - encoder.scoped_render_pass(device, &label, &wgpu::RenderPassDescriptor { + let _ = encoder.scoped_render_pass(&label, device, &wgpu::RenderPassDescriptor { label: Some(&label), color_attachments: &[], depth_stencil_attachment: Some( @@ -349,7 +349,7 @@ impl<'pass> ShadowPassDrawer<'pass> { pub fn draw_figure_shadows(&mut self) -> FigureShadowDrawer<'_, 'pass> { let mut render_pass = self .render_pass - .scope(self.borrow.device, "direcred_figure_shadows"); + .scope("direcred_figure_shadows", self.borrow.device); render_pass.set_pipeline(&self.shadow_renderer.figure_directed_pipeline.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -360,7 +360,7 @@ impl<'pass> ShadowPassDrawer<'pass> { pub fn draw_terrain_shadows(&mut self) -> TerrainShadowDrawer<'_, 'pass> { let mut render_pass = self .render_pass - .scope(self.borrow.device, "direcred_terrain_shadows"); + .scope("direcred_terrain_shadows", self.borrow.device); render_pass.set_pipeline(&self.shadow_renderer.terrain_directed_pipeline.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -412,7 +412,7 @@ pub struct FirstPassDrawer<'pass> { impl<'pass> FirstPassDrawer<'pass> { pub fn draw_skybox<'data: 'pass>(&mut self, model: &'data Model) { - let mut render_pass = self.render_pass.scope(self.borrow.device, "skybox"); + let mut render_pass = self.render_pass.scope("skybox", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.skybox.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -421,7 +421,7 @@ impl<'pass> FirstPassDrawer<'pass> { } pub fn draw_lod_terrain<'data: 'pass>(&mut self, model: &'data Model) { - let mut render_pass = self.render_pass.scope(self.borrow.device, "lod_terrain"); + let mut render_pass = self.render_pass.scope("lod_terrain", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.lod_terrain.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -430,7 +430,7 @@ impl<'pass> FirstPassDrawer<'pass> { } pub fn draw_figures(&mut self) -> FigureDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "figures"); + let mut render_pass = self.render_pass.scope("figures", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.figure.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -439,7 +439,7 @@ impl<'pass> FirstPassDrawer<'pass> { } pub fn draw_terrain<'data: 'pass>(&mut self) -> TerrainDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "terrain"); + let mut render_pass = self.render_pass.scope("terrain", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.terrain.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -451,7 +451,7 @@ impl<'pass> FirstPassDrawer<'pass> { } pub fn draw_particles(&mut self) -> ParticleDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "particles"); + let mut render_pass = self.render_pass.scope("particles", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.particle.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -464,7 +464,7 @@ impl<'pass> FirstPassDrawer<'pass> { globals: &'data sprite::SpriteGlobalsBindGroup, col_lights: &'data ColLights, ) -> SpriteDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "sprites"); + let mut render_pass = self.render_pass.scope("sprites", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.sprite.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -481,7 +481,7 @@ impl<'pass> FirstPassDrawer<'pass> { &mut self, waves: &'data fluid::BindGroup, ) -> FluidDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "fluid"); + let mut render_pass = self.render_pass.scope("fluid", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.fluid.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); @@ -643,14 +643,14 @@ pub struct ThirdPassDrawer<'pass> { impl<'pass> ThirdPassDrawer<'pass> { pub fn draw_post_process(&mut self) { - let mut render_pass = self.render_pass.scope(self.borrow.device, "postprocess"); + let mut render_pass = self.render_pass.scope("postprocess", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.postprocess.pipeline); render_pass.set_bind_group(1, &self.borrow.locals.postprocess_bind.bind_group, &[]); render_pass.draw(0..3, 0..1); } pub fn draw_ui(&mut self) -> UiDrawer<'_, 'pass> { - let mut render_pass = self.render_pass.scope(self.borrow.device, "ui"); + let mut render_pass = self.render_pass.scope("ui", self.borrow.device); render_pass.set_pipeline(&self.borrow.pipelines.ui.pipeline); set_quad_index_buffer::(&mut render_pass, &self.borrow); diff --git a/voxygen/src/render/scope.rs b/voxygen/src/render/scope.rs deleted file mode 100644 index e7135281f0..0000000000 --- a/voxygen/src/render/scope.rs +++ /dev/null @@ -1,163 +0,0 @@ -use wgpu_profiler::{GpuProfiler, ProfilerCommandRecorder}; - -pub struct Scope<'a, W: ProfilerCommandRecorder> { - profiler: &'a mut GpuProfiler, - wgpu_thing: &'a mut W, -} - -pub struct OwningScope<'a, W: ProfilerCommandRecorder> { - profiler: &'a mut GpuProfiler, - wgpu_thing: W, -} - -// Separate type since we can't destructure types that impl Drop :/ -pub struct ManualOwningScope<'a, W: ProfilerCommandRecorder> { - profiler: &'a mut GpuProfiler, - wgpu_thing: W, -} - -impl<'a, W: ProfilerCommandRecorder> Scope<'a, W> { - pub fn start( - profiler: &'a mut GpuProfiler, - wgpu_thing: &'a mut W, - device: &wgpu::Device, - label: &str, - ) -> Self { - profiler.begin_scope(label, wgpu_thing, device); - Self { - profiler, - wgpu_thing, - } - } - - /// Starts a scope nested within this one - pub fn scope(&mut self, device: &wgpu::Device, label: &str) -> Scope<'_, W> { - Scope::start(self.profiler, self.wgpu_thing, device, label) - } -} - -impl<'a, W: ProfilerCommandRecorder> OwningScope<'a, W> { - pub fn start( - profiler: &'a mut GpuProfiler, - mut wgpu_thing: W, - device: &wgpu::Device, - label: &str, - ) -> Self { - profiler.begin_scope(label, &mut wgpu_thing, device); - Self { - profiler, - wgpu_thing, - } - } - - /// Starts a scope nested within this one - pub fn scope(&mut self, device: &wgpu::Device, label: &str) -> Scope<'_, W> { - Scope::start(self.profiler, &mut self.wgpu_thing, device, label) - } -} - -impl<'a, W: ProfilerCommandRecorder> ManualOwningScope<'a, W> { - pub fn start( - profiler: &'a mut GpuProfiler, - mut wgpu_thing: W, - device: &wgpu::Device, - label: &str, - ) -> Self { - profiler.begin_scope(label, &mut wgpu_thing, device); - Self { - profiler, - wgpu_thing, - } - } - - /// Starts a scope nested within this one - pub fn scope(&mut self, device: &wgpu::Device, label: &str) -> Scope<'_, W> { - Scope::start(self.profiler, &mut self.wgpu_thing, device, label) - } - - /// Ends the scope allowing the extraction of owned the wgpu thing - /// and the mutable reference to the GpuProfiler - pub fn end_scope(mut self) -> (W, &'a mut GpuProfiler) { - self.profiler.end_scope(&mut self.wgpu_thing); - (self.wgpu_thing, self.profiler) - } -} -impl<'a> Scope<'a, wgpu::CommandEncoder> { - /// Start a render pass wrapped in an OwnedScope - pub fn scoped_render_pass<'b>( - &'b mut self, - device: &wgpu::Device, - label: &str, - pass_descriptor: &wgpu::RenderPassDescriptor<'b, '_>, - ) -> OwningScope<'b, wgpu::RenderPass> { - let render_pass = self.wgpu_thing.begin_render_pass(pass_descriptor); - OwningScope::start(self.profiler, render_pass, device, label) - } -} - -impl<'a> OwningScope<'a, wgpu::CommandEncoder> { - /// Start a render pass wrapped in an OwnedScope - pub fn scoped_render_pass<'b>( - &'b mut self, - device: &wgpu::Device, - label: &str, - pass_descriptor: &wgpu::RenderPassDescriptor<'b, '_>, - ) -> OwningScope<'b, wgpu::RenderPass> { - let render_pass = self.wgpu_thing.begin_render_pass(pass_descriptor); - OwningScope::start(self.profiler, render_pass, device, label) - } -} - -impl<'a> ManualOwningScope<'a, wgpu::CommandEncoder> { - /// Start a render pass wrapped in an OwnedScope - pub fn scoped_render_pass<'b>( - &'b mut self, - device: &wgpu::Device, - label: &str, - pass_descriptor: &wgpu::RenderPassDescriptor<'b, '_>, - ) -> OwningScope<'b, wgpu::RenderPass> { - let render_pass = self.wgpu_thing.begin_render_pass(pass_descriptor); - OwningScope::start(self.profiler, render_pass, device, label) - } -} - -// Scope -impl<'a, W: ProfilerCommandRecorder> std::ops::Deref for Scope<'a, W> { - type Target = W; - - fn deref(&self) -> &Self::Target { self.wgpu_thing } -} - -impl<'a, W: ProfilerCommandRecorder> std::ops::DerefMut for Scope<'a, W> { - fn deref_mut(&mut self) -> &mut Self::Target { self.wgpu_thing } -} - -impl<'a, W: ProfilerCommandRecorder> Drop for Scope<'a, W> { - fn drop(&mut self) { self.profiler.end_scope(self.wgpu_thing); } -} - -// OwningScope -impl<'a, W: ProfilerCommandRecorder> std::ops::Deref for OwningScope<'a, W> { - type Target = W; - - fn deref(&self) -> &Self::Target { &self.wgpu_thing } -} - -impl<'a, W: ProfilerCommandRecorder> std::ops::DerefMut for OwningScope<'a, W> { - fn deref_mut(&mut self) -> &mut Self::Target { &mut self.wgpu_thing } -} - -impl<'a, W: ProfilerCommandRecorder> Drop for OwningScope<'a, W> { - fn drop(&mut self) { self.profiler.end_scope(&mut self.wgpu_thing); } -} - -// ManualOwningScope -impl<'a, W: ProfilerCommandRecorder> std::ops::Deref for ManualOwningScope<'a, W> { - type Target = W; - - fn deref(&self) -> &Self::Target { &self.wgpu_thing } -} - -impl<'a, W: ProfilerCommandRecorder> std::ops::DerefMut for ManualOwningScope<'a, W> { - fn deref_mut(&mut self) -> &mut Self::Target { &mut self.wgpu_thing } -}