From 574656b767c95d0f8423f4ca90a3b3703ed26e3b Mon Sep 17 00:00:00 2001 From: Carter Anderson Date: Sun, 14 Jun 2020 12:32:06 -0700 Subject: [PATCH] render: remove RenderResources wrapper type --- crates/bevy_pbr/src/nodes/lights_node.rs | 16 ++--- crates/bevy_render/src/draw.rs | 13 ++-- crates/bevy_render/src/mesh.rs | 62 +++++++++---------- .../src/pipeline/pipeline_compiler.rs | 6 +- .../src/render_graph/nodes/camera_node.rs | 14 ++--- .../nodes/render_resources_node.rs | 36 +++++------ .../nodes/window_swapchain_node.rs | 6 +- .../render_graph/nodes/window_texture_node.rs | 6 +- .../src/render_resource/systems.rs | 14 ++--- .../src/renderer/render_resource_context.rs | 15 ----- crates/bevy_render/src/texture/texture.rs | 46 +++++++------- crates/bevy_ui/src/widget/label.rs | 4 +- .../wgpu_resource_diagnostics_plugin.rs | 7 +-- crates/bevy_wgpu/src/lib.rs | 7 +-- .../src/renderer/wgpu_render_context.rs | 16 ++--- .../renderer/wgpu_render_graph_executor.rs | 13 ++-- crates/bevy_wgpu/src/wgpu_render_pass.rs | 10 +-- crates/bevy_wgpu/src/wgpu_renderer.rs | 17 +++-- 18 files changed, 141 insertions(+), 167 deletions(-) diff --git a/crates/bevy_pbr/src/nodes/lights_node.rs b/crates/bevy_pbr/src/nodes/lights_node.rs index d16d90b900..786d1d1a0e 100644 --- a/crates/bevy_pbr/src/nodes/lights_node.rs +++ b/crates/bevy_pbr/src/nodes/lights_node.rs @@ -3,7 +3,7 @@ use bevy_render::{ render_resource::{ BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, }, - renderer::{RenderContext, RenderResources}, + renderer::{RenderContext, RenderResourceContext}, }; use crate::{ @@ -60,7 +60,7 @@ impl SystemNode for LightsNode { let mut command_queue = self.command_queue.clone(); let max_lights = self.max_lights; (move |world: &mut SubWorld, - render_resources: Res, + render_resource_context: Res>, // TODO: this write on RenderResourceAssignments will prevent this system from running in parallel with other systems that do the same mut render_resource_bindings: ResMut, query: &mut Query<(Read, Read, Read)>| { @@ -68,12 +68,12 @@ impl SystemNode for LightsNode { return; } - let render_resources = &render_resources.context; + let render_resource_context = &**render_resource_context; if light_buffer.is_none() { let light_uniform_size = std::mem::size_of::() + max_lights * std::mem::size_of::(); - let buffer = render_resources.create_buffer(BufferInfo { + let buffer = render_resource_context.create_buffer(BufferInfo { size: light_uniform_size, buffer_usage: BufferUsage::UNIFORM | BufferUsage::COPY_SRC @@ -103,14 +103,14 @@ impl SystemNode for LightsNode { let light_count_size = std::mem::size_of::(); if let Some(old_tmp_light_buffer) = tmp_light_buffer { - render_resources.remove_buffer(old_tmp_light_buffer); + render_resource_context.remove_buffer(old_tmp_light_buffer); } if let Some(old_tmp_count_buffer) = tmp_count_buffer { - render_resources.remove_buffer(old_tmp_count_buffer); + render_resource_context.remove_buffer(old_tmp_count_buffer); } - tmp_light_buffer = Some(render_resources.create_buffer_mapped( + tmp_light_buffer = Some(render_resource_context.create_buffer_mapped( BufferInfo { size: total_size, buffer_usage: BufferUsage::COPY_SRC, @@ -126,7 +126,7 @@ impl SystemNode for LightsNode { } }, )); - tmp_count_buffer = Some(render_resources.create_buffer_mapped( + tmp_count_buffer = Some(render_resource_context.create_buffer_mapped( BufferInfo { size: light_count_size, buffer_usage: BufferUsage::COPY_SRC, diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs index 6520048833..3c03225cb9 100644 --- a/crates/bevy_render/src/draw.rs +++ b/crates/bevy_render/src/draw.rs @@ -1,10 +1,10 @@ use crate::{ pipeline::{BindGroupDescriptor, BindGroupDescriptorId, PipelineDescriptor}, render_resource::{ - BufferId, BufferUsage, RenderResource, RenderResourceBinding, RenderResourceBindings, - BindGroup, BindGroupId, SharedBuffers, + BindGroup, BindGroupId, BufferId, BufferUsage, RenderResource, RenderResourceBinding, + RenderResourceBindings, SharedBuffers, }, - renderer::{RenderResourceContext, RenderResources}, + renderer::RenderResourceContext, }; use bevy_asset::{Assets, Handle}; use bevy_property::Properties; @@ -90,7 +90,7 @@ impl Draw { draw: self, pipelines, render_resource_context, - render_resource_bindings: render_resource_bindings, + render_resource_bindings, shared_buffers, current_pipeline: None, } @@ -252,15 +252,14 @@ impl Drawable for RenderPipelines { pub fn draw_system( pipelines: Res>, render_resource_bindings: Res, - render_resources: Res, + render_resource_context: Res>, shared_buffers: Res, mut draw: ComMut, mut drawable: ComMut, ) { - let context = &*render_resources.context; let mut draw_context = draw.get_context( &pipelines, - context, + &**render_resource_context, &render_resource_bindings, &shared_buffers, ); diff --git a/crates/bevy_render/src/mesh.rs b/crates/bevy_render/src/mesh.rs index 614b1dbf64..9725b6c7f4 100644 --- a/crates/bevy_render/src/mesh.rs +++ b/crates/bevy_render/src/mesh.rs @@ -4,7 +4,7 @@ use crate::{ AsVertexBufferDescriptor, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat, }, render_resource::{BufferInfo, BufferUsage, RenderResourceId}, - renderer::{RenderResourceContext, RenderResources}, + renderer::RenderResourceContext, RenderPipelines, Vertex, }; use bevy_app::{EventReader, Events}; @@ -321,20 +321,20 @@ pub mod shape { } fn remove_current_mesh_resources( - render_resources: &dyn RenderResourceContext, + render_resource_context: &dyn RenderResourceContext, handle: Handle, ) { if let Some(RenderResourceId::Buffer(buffer)) = - render_resources.get_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX) + render_resource_context.get_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX) { - render_resources.remove_buffer(buffer); - render_resources.remove_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX); + render_resource_context.remove_buffer(buffer); + render_resource_context.remove_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX); } if let Some(RenderResourceId::Buffer(buffer)) = - render_resources.get_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX) + render_resource_context.get_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX) { - render_resources.remove_buffer(buffer); - render_resources.remove_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX); + render_resource_context.remove_buffer(buffer); + render_resource_context.remove_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX); } } @@ -345,12 +345,12 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box, + render_resource_context: Res>, meshes: Res>, mesh_events: Res>>, query: &mut Query<(Read>, Write)>| { - let render_resources = &*render_resources.context; let mut changed_meshes = HashSet::new(); + let render_resource_context = &**render_resource_context; for event in mesh_event_reader.iter(&mesh_events) { match event { AssetEvent::Created { handle } => { @@ -358,10 +358,10 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box { changed_meshes.insert(*handle); - remove_current_mesh_resources(render_resources, *handle); + remove_current_mesh_resources(render_resource_context, *handle); } AssetEvent::Removed { handle } => { - remove_current_mesh_resources(render_resources, *handle); + remove_current_mesh_resources(render_resource_context, *handle); // if mesh was modified and removed in the same update, ignore the modification // events are ordered so future modification events are ok changed_meshes.remove(handle); @@ -375,7 +375,7 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box Box Box Box>, mut pipelines: ResMut>, vertex_buffer_descriptors: Res, - render_resources: Res, + render_resource_context: Res>, query: &mut Query>, ) { - let render_resource_context = &*render_resources.context; + let render_resource_context = &**render_resource_context; // TODO: only update when RenderPipelines is changed for mut render_pipelines in query.iter_mut(world) { diff --git a/crates/bevy_render/src/render_graph/nodes/camera_node.rs b/crates/bevy_render/src/render_graph/nodes/camera_node.rs index ba52e532be..c9776bad89 100644 --- a/crates/bevy_render/src/render_graph/nodes/camera_node.rs +++ b/crates/bevy_render/src/render_graph/nodes/camera_node.rs @@ -1,9 +1,7 @@ use crate::{ render_graph::{CommandQueue, Node, ResourceSlots, SystemNode}, - render_resource::{ - BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, - }, - renderer::{RenderContext, RenderResources}, + render_resource::{BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings}, + renderer::{RenderResourceContext, RenderContext}, Camera, }; use bevy_core::bytes::AsBytes; @@ -48,15 +46,15 @@ impl SystemNode for CameraNode { let mut command_queue = self.command_queue.clone(); let uniform_name = self.uniform_name.clone(); (move |world: &mut SubWorld, - render_resources: Res, + render_resource_context: Res>, // PERF: this write on RenderResourceAssignments will prevent this system from running in parallel // with other systems that do the same mut render_resource_bindings: ResMut, query: &mut Query<(Read, Read)>| { - let render_resources = &render_resources.context; + let render_resource_context = &**render_resource_context; if camera_buffer.is_none() { let size = std::mem::size_of::<[[f32; 4]; 4]>(); - let buffer = render_resources.create_buffer(BufferInfo { + let buffer = render_resource_context.create_buffer(BufferInfo { size, buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM, ..Default::default() @@ -79,7 +77,7 @@ impl SystemNode for CameraNode { let camera_matrix: [f32; 16] = (camera.view_matrix * transform.value).to_cols_array(); - let tmp_buffer = render_resources.create_buffer_mapped( + let tmp_buffer = render_resource_context.create_buffer_mapped( BufferInfo { size: matrix_size, buffer_usage: BufferUsage::COPY_SRC, diff --git a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs index ffe8385d65..573302faf4 100644 --- a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs +++ b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs @@ -5,7 +5,7 @@ use crate::{ self, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, RenderResourceBindingsId, RenderResourceHints, }, - renderer::{RenderContext, RenderResourceContext, RenderResources}, + renderer::{RenderContext, RenderResourceContext}, texture, }; @@ -196,7 +196,7 @@ where &mut self, uniforms: &T, dynamic_uniforms: bool, - render_resources: &dyn RenderResourceContext, + render_resource_context: &dyn RenderResourceContext, render_resource_bindings: &mut RenderResourceBindings, staging_buffer: &mut [u8], ) { @@ -209,8 +209,8 @@ where let range = 0..size as u64; let (target_buffer, target_offset) = if dynamic_uniforms { let buffer = uniform_buffer_status.buffer.unwrap(); - let index = uniform_buffer_status - .get_or_assign_index(render_resource_bindings.id); + let index = + uniform_buffer_status.get_or_assign_index(render_resource_bindings.id); render_resource_bindings.set( render_resource_name, RenderResourceBinding::Buffer { @@ -225,13 +225,11 @@ where } else { let mut matching_buffer = None; let mut buffer_to_remove = None; - if let Some(binding) = - render_resource_bindings.get(render_resource_name) - { + if let Some(binding) = render_resource_bindings.get(render_resource_name) { let buffer_id = binding.get_buffer().unwrap(); if let Some(BufferInfo { size: current_size, .. - }) = render_resources.get_buffer_info(buffer_id) + }) = render_resource_context.get_buffer_info(buffer_id) { if size == current_size { matching_buffer = Some(buffer_id); @@ -243,7 +241,7 @@ where } if let Some(buffer) = buffer_to_remove { - render_resources.remove_buffer(buffer); + render_resource_context.remove_buffer(buffer); } let resource = if let Some(matching_buffer) = matching_buffer { @@ -258,7 +256,7 @@ where } } - let buffer = render_resources.create_buffer(BufferInfo { + let buffer = render_resource_context.create_buffer(BufferInfo { size, buffer_usage: BufferUsage::COPY_DST | usage, ..Default::default() @@ -373,10 +371,10 @@ where let dynamic_uniforms = self.dynamic_uniforms; // TODO: maybe run "update" here (move |world: &mut SubWorld, - render_resources: Res, + render_resource_context: Res>, query: &mut Query<(Read, Read, Write)>| { - let render_resource_context = &*render_resources.context; - + + let render_resource_context = &** render_resource_context; uniform_buffer_arrays.reset_changed_item_counts(); // update uniforms info for (uniforms, draw, _render_pipelines) in query.iter_mut(world) { @@ -424,7 +422,7 @@ where size: staging_buffer_size, ..Default::default() }, - &mut |mut staging_buffer, _render_resources| { + &mut |mut staging_buffer, _render_resource_context| { for (uniforms, draw, mut render_pipelines) in query.iter_mut(world) { if !draw.is_visible { return; @@ -505,9 +503,9 @@ where (move |world: &mut SubWorld, assets: Res>, // asset_events: Res>>, - render_resources: Res, + render_resource_context: Res>, query: &mut Query<(Read>, Read, Write)>| { - let render_resource_context = &*render_resources.context; + let render_resource_context = &**render_resource_context; uniform_buffer_arrays.reset_changed_item_counts(); let modified_assets = assets @@ -575,7 +573,7 @@ where size: staging_buffer_size, ..Default::default() }, - &mut |mut staging_buffer, _render_resources| { + &mut |mut staging_buffer, _render_resource_context| { for asset_handle in modified_assets.iter() { let asset = assets.get(&asset_handle).expect(EXPECT_ASSET_MESSAGE); let mut render_resource_bindings = asset_render_resource_bindings @@ -599,9 +597,7 @@ where } for (asset_handle, _draw, mut render_pipelines) in query.iter_mut(world) { - if let Some(asset_bindings) = - asset_render_resource_bindings.get(&asset_handle) - { + if let Some(asset_bindings) = asset_render_resource_bindings.get(&asset_handle) { render_pipelines .render_resource_bindings .extend(asset_bindings); diff --git a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs index 31cc872953..67f3332be2 100644 --- a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs +++ b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs @@ -54,7 +54,7 @@ impl Node for WindowSwapChainNode { .expect("Received window resized event for non-existent window"), }; - let render_resources = render_context.resources_mut(); + let render_resource_context = render_context.resources_mut(); // create window swapchain when window is resized or created if self @@ -66,10 +66,10 @@ impl Node for WindowSwapChainNode { .find_latest(&window_resized_events, |e| e.id == window.id) .is_some() { - render_resources.create_swap_chain(window); + render_resource_context.create_swap_chain(window); } - let swap_chain_texture = render_resources.next_swap_chain_texture(window.id); + let swap_chain_texture = render_resource_context.next_swap_chain_texture(window.id); output.set(WINDOW_TEXTURE, RenderResourceId::Texture(swap_chain_texture)); } } diff --git a/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs b/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs index 70be9f93e2..d3029ab80e 100644 --- a/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs +++ b/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs @@ -66,14 +66,14 @@ impl Node for WindowTextureNode { .find_latest(&window_resized_events, |e| e.id == window.id) .is_some() { - let render_resources = render_context.resources_mut(); + let render_resource_context = render_context.resources_mut(); if let Some(RenderResourceId::Texture(old_texture)) = output.get(WINDOW_TEXTURE) { - render_resources.remove_texture(old_texture); + render_resource_context.remove_texture(old_texture); } self.descriptor.size.width = window.width; self.descriptor.size.height = window.height; - let texture_resource = render_resources.create_texture(self.descriptor); + let texture_resource = render_resource_context.create_texture(self.descriptor); output.set(WINDOW_TEXTURE, RenderResourceId::Texture(texture_resource)); } } diff --git a/crates/bevy_render/src/render_resource/systems.rs b/crates/bevy_render/src/render_resource/systems.rs index 6293a0b397..0c75fab999 100644 --- a/crates/bevy_render/src/render_resource/systems.rs +++ b/crates/bevy_render/src/render_resource/systems.rs @@ -1,10 +1,10 @@ -use bevy_asset::Assets; use crate::{ draw::RenderPipelines, pipeline::{PipelineCompiler, PipelineDescriptor}, - render_resource::{RenderResourceBindings, BindGroupStatus}, - renderer::{RenderResourceContext, RenderResources}, + render_resource::{BindGroupStatus, RenderResourceBindings}, + renderer::RenderResourceContext, }; +use bevy_asset::Assets; use legion::prelude::*; fn update_bind_groups( @@ -20,7 +20,7 @@ fn update_bind_groups( .get_bind_group(id) .expect("RenderResourceSet was just changed, so it should exist"); render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group); - }, + } // TODO: Don't re-create bind groups if they havent changed. this will require cleanup of orphan bind groups and // removal of global context.clear_bind_groups() // PERF: see above @@ -29,7 +29,7 @@ fn update_bind_groups( .get_bind_group(id) .expect("RenderResourceSet was just changed, so it should exist"); render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group); - }, + } BindGroupStatus::NoMatch => { // ignore unchanged / unmatched render resource sets } @@ -41,11 +41,11 @@ pub fn bind_groups_system( world: &mut SubWorld, pipelines: Res>, pipeline_compiler: Res, - render_resources: Res, + render_resource_context: Res>, mut render_resource_bindings: ResMut, query: &mut Query>, ) { - let render_resource_context = &*render_resources.context; + let render_resource_context = &**render_resource_context; for compiled_pipeline_handle in pipeline_compiler.iter_all_compiled_pipelines() { let pipeline = pipelines.get(compiled_pipeline_handle).unwrap(); update_bind_groups( diff --git a/crates/bevy_render/src/renderer/render_resource_context.rs b/crates/bevy_render/src/renderer/render_resource_context.rs index 015df00d72..215ee3132b 100644 --- a/crates/bevy_render/src/renderer/render_resource_context.rs +++ b/crates/bevy_render/src/renderer/render_resource_context.rs @@ -8,21 +8,6 @@ use bevy_asset::{Assets, Handle, HandleUntyped}; use bevy_window::{Window, WindowId}; use downcast_rs::{impl_downcast, Downcast}; -pub struct RenderResources { - pub context: Box, -} - -impl RenderResources { - pub fn new(context: T) -> RenderResources - where - T: RenderResourceContext, - { - RenderResources { - context: Box::new(context), - } - } -} - pub trait RenderResourceContext: Downcast + Send + Sync + 'static { fn create_swap_chain(&self, window: &Window); fn next_swap_chain_texture(&self, window_id: WindowId) -> TextureId; diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs index a895417b74..1063692eff 100644 --- a/crates/bevy_render/src/texture/texture.rs +++ b/crates/bevy_render/src/texture/texture.rs @@ -1,7 +1,7 @@ use super::{SamplerDescriptor, TextureDescriptor}; use crate::{ - renderer::{RenderResourceContext, RenderResources}, - render_resource::{ResourceInfo, RenderResource, RenderResourceId}, + render_resource::{RenderResource, RenderResourceId, ResourceInfo}, + renderer::RenderResourceContext, }; use bevy_app::{EventReader, Events}; use bevy_asset::{AssetEvent, Assets, Handle}; @@ -47,11 +47,11 @@ impl Texture { pub fn texture_resource_system( mut state: ResMut, - render_resources: Res, + render_resource_context: Res>, textures: Res>, texture_events: Res>>, ) { - let render_resources = &*render_resources.context; + let render_resource_context = &**render_resource_context; let mut changed_textures = HashSet::new(); for event in state.event_reader.iter(&texture_events) { match event { @@ -60,10 +60,10 @@ impl Texture { } AssetEvent::Modified { handle } => { changed_textures.insert(*handle); - Self::remove_current_texture_resources(render_resources, *handle); + Self::remove_current_texture_resources(render_resource_context, *handle); } AssetEvent::Removed { handle } => { - Self::remove_current_texture_resources(render_resources, *handle); + Self::remove_current_texture_resources(render_resource_context, *handle); // if texture was modified and removed in the same update, ignore the modification // events are ordered so future modification events are ok changed_textures.remove(handle); @@ -74,17 +74,17 @@ impl Texture { for texture_handle in changed_textures.iter() { if let Some(texture) = textures.get(texture_handle) { let texture_descriptor: TextureDescriptor = texture.into(); - let texture_resource = render_resources.create_texture(texture_descriptor); + let texture_resource = render_resource_context.create_texture(texture_descriptor); let sampler_descriptor: SamplerDescriptor = texture.into(); - let sampler_resource = render_resources.create_sampler(&sampler_descriptor); + let sampler_resource = render_resource_context.create_sampler(&sampler_descriptor); - render_resources.set_asset_resource( + render_resource_context.set_asset_resource( *texture_handle, RenderResourceId::Texture(texture_resource), TEXTURE_ASSET_INDEX, ); - render_resources.set_asset_resource( + render_resource_context.set_asset_resource( *texture_handle, RenderResourceId::Sampler(sampler_resource), SAMPLER_ASSET_INDEX, @@ -94,16 +94,20 @@ impl Texture { } fn remove_current_texture_resources( - render_resources: &dyn RenderResourceContext, + render_resource_context: &dyn RenderResourceContext, handle: Handle, ) { - if let Some(RenderResourceId::Texture(resource)) = render_resources.get_asset_resource(handle, TEXTURE_ASSET_INDEX) { - render_resources.remove_texture(resource); - render_resources.remove_asset_resource(handle, TEXTURE_ASSET_INDEX); + if let Some(RenderResourceId::Texture(resource)) = + render_resource_context.get_asset_resource(handle, TEXTURE_ASSET_INDEX) + { + render_resource_context.remove_texture(resource); + render_resource_context.remove_asset_resource(handle, TEXTURE_ASSET_INDEX); } - if let Some(RenderResourceId::Sampler(resource)) = render_resources.get_asset_resource(handle, SAMPLER_ASSET_INDEX) { - render_resources.remove_sampler(resource); - render_resources.remove_asset_resource(handle, SAMPLER_ASSET_INDEX); + if let Some(RenderResourceId::Sampler(resource)) = + render_resource_context.get_asset_resource(handle, SAMPLER_ASSET_INDEX) + { + render_resource_context.remove_sampler(resource); + render_resource_context.remove_asset_resource(handle, SAMPLER_ASSET_INDEX); } } } @@ -117,8 +121,7 @@ impl RenderResource for Option> { fn resource_info(&self) -> Option { self.map(|_texture| ResourceInfo::Texture(None)) } - fn write_buffer_bytes(&self, _buffer: &mut [u8]) { - } + fn write_buffer_bytes(&self, _buffer: &mut [u8]) {} fn buffer_byte_len(&self) -> Option { None } @@ -131,12 +134,11 @@ impl RenderResource for Handle { fn resource_info(&self) -> Option { Some(ResourceInfo::Texture(None)) } - fn write_buffer_bytes(&self, _buffer: &mut [u8]) { - } + fn write_buffer_bytes(&self, _buffer: &mut [u8]) {} fn buffer_byte_len(&self) -> Option { None } fn texture(&self) -> Option> { Some(self.clone()) } -} \ No newline at end of file +} diff --git a/crates/bevy_ui/src/widget/label.rs b/crates/bevy_ui/src/widget/label.rs index c160ea4f7d..8d085222f0 100644 --- a/crates/bevy_ui/src/widget/label.rs +++ b/crates/bevy_ui/src/widget/label.rs @@ -3,7 +3,7 @@ use bevy_render::{ draw::Draw, pipeline::PipelineDescriptor, render_resource::{RenderResourceBindings, SharedBuffers}, - renderer::RenderResources, + renderer::RenderResourceContext, texture::Texture, Color, }; @@ -80,7 +80,7 @@ impl Label { pub fn draw_label_system( _pipelines: Res>, _render_resource_bindings: Res, - _render_resources: Res, + _render_resource_context: Res>, _shared_buffers: Res, _fonts: Res>, _font_atlas_sets: Res>, diff --git a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs index 9ed9c62050..733bb53aab 100644 --- a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs +++ b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs @@ -1,7 +1,7 @@ use crate::renderer::WgpuRenderResourceContext; use bevy_app::{AppBuilder, AppPlugin}; use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics}; -use bevy_render::renderer::RenderResources; +use bevy_render::renderer::RenderResourceContext; use legion::prelude::{IntoSystem, Res, ResMut}; #[derive(Default)] @@ -94,10 +94,9 @@ impl WgpuResourceDiagnosticsPlugin { pub fn diagnostic_system( mut diagnostics: ResMut, - render_resources: Res, + render_resource_context: Res>, ) { - let render_resource_context = render_resources - .context + let render_resource_context = render_resource_context .downcast_ref::() .unwrap(); diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs index 41067fa8d9..4e9eb0e9b6 100644 --- a/crates/bevy_wgpu/src/lib.rs +++ b/crates/bevy_wgpu/src/lib.rs @@ -10,10 +10,7 @@ pub use wgpu_renderer::*; pub use wgpu_resources::*; use bevy_app::{AppBuilder, AppPlugin}; -use bevy_render::{ - render_resource::{free_shared_buffers_system, SharedBuffers}, - renderer::RenderResources, -}; +use bevy_render::{renderer::RenderResourceContext, render_resource::{free_shared_buffers_system, SharedBuffers}}; use legion::prelude::*; use renderer::WgpuRenderResourceContext; @@ -33,7 +30,7 @@ impl AppPlugin for WgpuPlugin { pub fn wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut World, &mut Resources) { let mut wgpu_renderer = pollster::block_on(WgpuRenderer::new()); - resources.insert(RenderResources::new(WgpuRenderResourceContext::new( + resources.insert::>(Box::new(WgpuRenderResourceContext::new( wgpu_renderer.device.clone(), ))); resources.insert(SharedBuffers::new(Box::new( diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs index 8f1529cee8..d9744b5a7e 100644 --- a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs +++ b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs @@ -51,14 +51,14 @@ impl LazyCommandEncoder { pub struct WgpuRenderContext { pub device: Arc, pub command_encoder: LazyCommandEncoder, - pub render_resources: WgpuRenderResourceContext, + pub render_resource_context: WgpuRenderResourceContext, } impl WgpuRenderContext { pub fn new(device: Arc, resources: WgpuRenderResourceContext) -> Self { WgpuRenderContext { device, - render_resources: resources, + render_resource_context: resources, command_encoder: LazyCommandEncoder::default(), } } @@ -79,7 +79,7 @@ impl RenderContext for WgpuRenderContext { destination_offset: u64, size: u64, ) { - self.render_resources.copy_buffer_to_buffer( + self.render_resource_context.copy_buffer_to_buffer( self.command_encoder.get_or_create(&self.device), source_buffer, source_offset, @@ -99,7 +99,7 @@ impl RenderContext for WgpuRenderContext { destination_mip_level: u32, size: Extent3d, ) { - self.render_resources.copy_buffer_to_texture( + self.render_resource_context.copy_buffer_to_texture( self.command_encoder.get_or_create(&self.device), source_buffer, source_offset, @@ -112,10 +112,10 @@ impl RenderContext for WgpuRenderContext { } fn resources(&self) -> &dyn RenderResourceContext { - &self.render_resources + &self.render_resource_context } fn resources_mut(&mut self) -> &mut dyn RenderResourceContext { - &mut self.render_resources + &mut self.render_resource_context } fn begin_pass( @@ -127,7 +127,7 @@ impl RenderContext for WgpuRenderContext { if !self.command_encoder.is_some() { self.command_encoder.create(&self.device); } - let resource_lock = self.render_resources.resources.read(); + let resource_lock = self.render_resource_context.resources.read(); let refs = resource_lock.refs(); let mut encoder = self.command_encoder.take().unwrap(); { @@ -140,7 +140,7 @@ impl RenderContext for WgpuRenderContext { let mut wgpu_render_pass = WgpuRenderPass { render_pass, render_context: self, - render_resources: refs, + wgpu_resources: refs, pipeline_descriptor: None, }; diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs index b5582f12be..ff0f10bfe0 100644 --- a/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs +++ b/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs @@ -1,7 +1,7 @@ use super::{WgpuRenderContext, WgpuRenderResourceContext}; use bevy_render::{ render_graph::{Edge, NodeId, ResourceSlots, StageBorrow}, - renderer::RenderResources, + renderer::RenderResourceContext, }; use legion::prelude::{Resources, World}; use std::{ @@ -22,9 +22,10 @@ impl WgpuRenderGraphExecutor { queue: &mut wgpu::Queue, stages: &mut [StageBorrow], ) { - let mut render_resources = resources.get_mut::().unwrap(); - let wgpu_render_resources = render_resources - .context + let mut render_resource_context = resources + .get_mut::>() + .unwrap(); + let render_resource_context = render_resource_context .downcast_mut::() .unwrap(); let node_outputs: Arc>> = Default::default(); @@ -41,10 +42,10 @@ impl WgpuRenderGraphExecutor { let world = &*world; actual_thread_count += 1; let device = device.clone(); - let wgpu_render_resources = wgpu_render_resources.clone(); + let render_resource_context = render_resource_context.clone(); let node_outputs = node_outputs.clone(); // s.spawn(move |_| { - let mut render_context = WgpuRenderContext::new(device, wgpu_render_resources); + let mut render_context = WgpuRenderContext::new(device, render_resource_context); for job in jobs_chunk.iter_mut() { for node_state in job.node_states.iter_mut() { // bind inputs from connected node outputs diff --git a/crates/bevy_wgpu/src/wgpu_render_pass.rs b/crates/bevy_wgpu/src/wgpu_render_pass.rs index 84288dbda1..eb7cc5704c 100644 --- a/crates/bevy_wgpu/src/wgpu_render_pass.rs +++ b/crates/bevy_wgpu/src/wgpu_render_pass.rs @@ -11,7 +11,7 @@ use std::ops::Range; pub struct WgpuRenderPass<'a> { pub render_pass: wgpu::RenderPass<'a>, pub render_context: &'a WgpuRenderContext, - pub render_resources: WgpuResourceRefs<'a>, + pub wgpu_resources: WgpuResourceRefs<'a>, pub pipeline_descriptor: Option<&'a PipelineDescriptor>, } @@ -21,7 +21,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> { } fn set_vertex_buffer(&mut self, start_slot: u32, buffer_id: BufferId, offset: u64) { - let buffer = self.render_resources.buffers.get(&buffer_id).unwrap(); + let buffer = self.wgpu_resources.buffers.get(&buffer_id).unwrap(); self.render_pass .set_vertex_buffer(start_slot, buffer.slice(offset..)); } @@ -36,7 +36,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> { } fn set_index_buffer(&mut self, buffer_id: BufferId, offset: u64) { - let buffer = self.render_resources.buffers.get(&buffer_id).unwrap(); + let buffer = self.wgpu_resources.buffers.get(&buffer_id).unwrap(); self.render_pass.set_index_buffer(buffer.slice(offset..)); } @@ -57,7 +57,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> { dynamic_uniform_indices: Option<&[u32]>, ) { if let Some(bind_group_info) = self - .render_resources + .wgpu_resources .bind_groups .get(&bind_group_descriptor) { @@ -83,7 +83,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> { } fn set_pipeline(&mut self, pipeline_handle: Handle) { - let pipeline = self.render_resources.render_pipelines.get(&pipeline_handle).expect( + let pipeline = self.wgpu_resources.render_pipelines.get(&pipeline_handle).expect( "Attempted to use a pipeline that does not exist in this RenderPass's RenderContext", ); self.render_pass.set_pipeline(pipeline); diff --git a/crates/bevy_wgpu/src/wgpu_renderer.rs b/crates/bevy_wgpu/src/wgpu_renderer.rs index 6d4c99e856..b72bcd898a 100644 --- a/crates/bevy_wgpu/src/wgpu_renderer.rs +++ b/crates/bevy_wgpu/src/wgpu_renderer.rs @@ -2,7 +2,7 @@ use crate::renderer::{WgpuRenderGraphExecutor, WgpuRenderResourceContext}; use bevy_app::{EventReader, Events}; use bevy_render::{ render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager}, - renderer::RenderResources, + renderer::RenderResourceContext, }; use bevy_window::{WindowCreated, WindowResized, Windows}; use legion::prelude::*; @@ -54,9 +54,10 @@ impl WgpuRenderer { } pub fn handle_window_created_events(&mut self, resources: &Resources) { - let mut render_resources = resources.get_mut::().unwrap(); - let render_resource_context = render_resources - .context + let mut render_resource_context = resources + .get_mut::>() + .unwrap(); + let render_resource_context = render_resource_context .downcast_mut::() .unwrap(); let windows = resources.get::().unwrap(); @@ -102,10 +103,8 @@ impl WgpuRenderer { self.handle_window_created_events(resources); self.run_graph(world, resources); - let render_resource_context = resources.get::().unwrap(); - render_resource_context - .context - .drop_all_swap_chain_textures(); - render_resource_context.context.clear_bind_groups(); + let render_resource_context = resources.get::>().unwrap(); + render_resource_context.drop_all_swap_chain_textures(); + render_resource_context.clear_bind_groups(); } }