forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

render: remove RenderResources wrapper type

Browse Source
This commit is contained in:
Carter Anderson 2020-06-14 12:32:06 -07:00
parent 0fec350411
commit 574656b767
18 changed files with 141 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
crates/bevy_pbr/src/nodes/lights_node.rs
View File

@ -3,7 +3,7 @@ use bevy_render::{
render_resource::{ render_resource::{
BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
}, },
renderer::{RenderContext, RenderResources}, renderer::{RenderContext, RenderResourceContext},
}; };
use crate::{ use crate::{
@ -60,7 +60,7 @@ impl SystemNode for LightsNode {
let mut command_queue = self.command_queue.clone(); let mut command_queue = self.command_queue.clone();
let max_lights = self.max_lights; let max_lights = self.max_lights;
(move |world: &mut SubWorld, (move |world: &mut SubWorld,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
// TODO: this write on RenderResourceAssignments will prevent this system from running in parallel with other systems that do the same // 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<RenderResourceBindings>, mut render_resource_bindings: ResMut<RenderResourceBindings>,
query: &mut Query<(Read<Light>, Read<Transform>, Read<Translation>)>| { query: &mut Query<(Read<Light>, Read<Transform>, Read<Translation>)>| {
@ -68,12 +68,12 @@ impl SystemNode for LightsNode {
return; return;
} }
let render_resources = &render_resources.context; let render_resource_context = &**render_resource_context;
if light_buffer.is_none() { if light_buffer.is_none() {
let light_uniform_size = std::mem::size_of::<LightCount>() let light_uniform_size = std::mem::size_of::<LightCount>()
+ max_lights * std::mem::size_of::<LightRaw>(); + max_lights * std::mem::size_of::<LightRaw>();
let buffer = render_resources.create_buffer(BufferInfo { let buffer = render_resource_context.create_buffer(BufferInfo {
size: light_uniform_size, size: light_uniform_size,
buffer_usage: BufferUsage::UNIFORM buffer_usage: BufferUsage::UNIFORM
| BufferUsage::COPY_SRC | BufferUsage::COPY_SRC
@ -103,14 +103,14 @@ impl SystemNode for LightsNode {
let light_count_size = std::mem::size_of::<LightCount>(); let light_count_size = std::mem::size_of::<LightCount>();
if let Some(old_tmp_light_buffer) = tmp_light_buffer { 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 { 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 { BufferInfo {
size: total_size, size: total_size,
buffer_usage: BufferUsage::COPY_SRC, 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 { BufferInfo {
size: light_count_size, size: light_count_size,
buffer_usage: BufferUsage::COPY_SRC, buffer_usage: BufferUsage::COPY_SRC,

13
crates/bevy_render/src/draw.rs
View File

@ -1,10 +1,10 @@
use crate::{ use crate::{
pipeline::{BindGroupDescriptor, BindGroupDescriptorId, PipelineDescriptor}, pipeline::{BindGroupDescriptor, BindGroupDescriptorId, PipelineDescriptor},
render_resource::{ render_resource::{
BufferId, BufferUsage, RenderResource, RenderResourceBinding, RenderResourceBindings, BindGroup, BindGroupId, BufferId, BufferUsage, RenderResource, RenderResourceBinding,
BindGroup, BindGroupId, SharedBuffers, RenderResourceBindings, SharedBuffers,
}, },
renderer::{RenderResourceContext, RenderResources}, renderer::RenderResourceContext,
}; };
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, Handle};
use bevy_property::Properties; use bevy_property::Properties;
@ -90,7 +90,7 @@ impl Draw {
draw: self, draw: self,
pipelines, pipelines,
render_resource_context, render_resource_context,
render_resource_bindings: render_resource_bindings, render_resource_bindings,
shared_buffers, shared_buffers,
current_pipeline: None, current_pipeline: None,
} }
@ -252,15 +252,14 @@ impl Drawable for RenderPipelines {
pub fn draw_system<T: Drawable + Component>( pub fn draw_system<T: Drawable + Component>(
pipelines: Res<Assets<PipelineDescriptor>>, pipelines: Res<Assets<PipelineDescriptor>>,
render_resource_bindings: Res<RenderResourceBindings>, render_resource_bindings: Res<RenderResourceBindings>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
shared_buffers: Res<SharedBuffers>, shared_buffers: Res<SharedBuffers>,
mut draw: ComMut<Draw>, mut draw: ComMut<Draw>,
mut drawable: ComMut<T>, mut drawable: ComMut<T>,
) { ) {
let context = &*render_resources.context;
let mut draw_context = draw.get_context( let mut draw_context = draw.get_context(
&pipelines, &pipelines,
context, &**render_resource_context,
&render_resource_bindings, &render_resource_bindings,
&shared_buffers, &shared_buffers,
); );

40
crates/bevy_render/src/mesh.rs
View File

@ -4,7 +4,7 @@ use crate::{
AsVertexBufferDescriptor, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat, AsVertexBufferDescriptor, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
}, },
render_resource::{BufferInfo, BufferUsage, RenderResourceId}, render_resource::{BufferInfo, BufferUsage, RenderResourceId},
renderer::{RenderResourceContext, RenderResources}, renderer::RenderResourceContext,
RenderPipelines, Vertex, RenderPipelines, Vertex,
}; };
use bevy_app::{EventReader, Events}; use bevy_app::{EventReader, Events};
@ -321,20 +321,20 @@ pub mod shape {
} }
fn remove_current_mesh_resources( fn remove_current_mesh_resources(
render_resources: &dyn RenderResourceContext, render_resource_context: &dyn RenderResourceContext,
handle: Handle<Mesh>, handle: Handle<Mesh>,
) { ) {
if let Some(RenderResourceId::Buffer(buffer)) = 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_resource_context.remove_buffer(buffer);
render_resources.remove_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX); render_resource_context.remove_asset_resource(handle, VERTEX_BUFFER_ASSET_INDEX);
} }
if let Some(RenderResourceId::Buffer(buffer)) = 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_resource_context.remove_buffer(buffer);
render_resources.remove_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX); 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<dyn Sched
let vertex_buffer_descriptor = Vertex::as_vertex_buffer_descriptor(); let vertex_buffer_descriptor = Vertex::as_vertex_buffer_descriptor();
vertex_buffer_descriptors.set(vertex_buffer_descriptor.clone()); vertex_buffer_descriptors.set(vertex_buffer_descriptor.clone());
(move |world: &mut SubWorld, (move |world: &mut SubWorld,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
meshes: Res<Assets<Mesh>>, meshes: Res<Assets<Mesh>>,
mesh_events: Res<Events<AssetEvent<Mesh>>>, mesh_events: Res<Events<AssetEvent<Mesh>>>,
query: &mut Query<(Read<Handle<Mesh>>, Write<RenderPipelines>)>| { query: &mut Query<(Read<Handle<Mesh>>, Write<RenderPipelines>)>| {
let render_resources = &*render_resources.context;
let mut changed_meshes = HashSet::new(); let mut changed_meshes = HashSet::new();
let render_resource_context = &**render_resource_context;
for event in mesh_event_reader.iter(&mesh_events) { for event in mesh_event_reader.iter(&mesh_events) {
match event { match event {
AssetEvent::Created { handle } => { AssetEvent::Created { handle } => {
@ -358,10 +358,10 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
} }
AssetEvent::Modified { handle } => { AssetEvent::Modified { handle } => {
changed_meshes.insert(*handle); changed_meshes.insert(*handle);
remove_current_mesh_resources(render_resources, *handle); remove_current_mesh_resources(render_resource_context, *handle);
} }
AssetEvent::Removed { 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 // if mesh was modified and removed in the same update, ignore the modification
// events are ordered so future modification events are ok // events are ordered so future modification events are ok
changed_meshes.remove(handle); changed_meshes.remove(handle);
@ -375,7 +375,7 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
.get_vertex_buffer_bytes(&vertex_buffer_descriptor) .get_vertex_buffer_bytes(&vertex_buffer_descriptor)
.unwrap(); .unwrap();
// TODO: use a staging buffer here // TODO: use a staging buffer here
let vertex_buffer = render_resources.create_buffer_with_data( let vertex_buffer = render_resource_context.create_buffer_with_data(
BufferInfo { BufferInfo {
buffer_usage: BufferUsage::VERTEX, buffer_usage: BufferUsage::VERTEX,
..Default::default() ..Default::default()
@ -384,7 +384,7 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
); );
let index_bytes = mesh.get_index_buffer_bytes(IndexFormat::Uint16).unwrap(); let index_bytes = mesh.get_index_buffer_bytes(IndexFormat::Uint16).unwrap();
let index_buffer = render_resources.create_buffer_with_data( let index_buffer = render_resource_context.create_buffer_with_data(
BufferInfo { BufferInfo {
buffer_usage: BufferUsage::INDEX, buffer_usage: BufferUsage::INDEX,
..Default::default() ..Default::default()
@ -392,12 +392,12 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
&index_bytes, &index_bytes,
); );
render_resources.set_asset_resource( render_resource_context.set_asset_resource(
*changed_mesh_handle, *changed_mesh_handle,
RenderResourceId::Buffer(vertex_buffer), RenderResourceId::Buffer(vertex_buffer),
VERTEX_BUFFER_ASSET_INDEX, VERTEX_BUFFER_ASSET_INDEX,
); );
render_resources.set_asset_resource( render_resource_context.set_asset_resource(
*changed_mesh_handle, *changed_mesh_handle,
RenderResourceId::Buffer(index_buffer), RenderResourceId::Buffer(index_buffer),
INDEX_BUFFER_ASSET_INDEX, INDEX_BUFFER_ASSET_INDEX,
@ -415,14 +415,12 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
} }
if let Some(RenderResourceId::Buffer(vertex_buffer)) = if let Some(RenderResourceId::Buffer(vertex_buffer)) =
render_resources.get_asset_resource(*handle, VERTEX_BUFFER_ASSET_INDEX) render_resource_context.get_asset_resource(*handle, VERTEX_BUFFER_ASSET_INDEX)
{ {
render_pipelines render_pipelines.render_resource_bindings.set_vertex_buffer(
.render_resource_bindings
.set_vertex_buffer(
"Vertex", "Vertex",
vertex_buffer, vertex_buffer,
render_resources render_resource_context
.get_asset_resource(*handle, INDEX_BUFFER_ASSET_INDEX) .get_asset_resource(*handle, INDEX_BUFFER_ASSET_INDEX)
.and_then(|r| { .and_then(|r| {
if let RenderResourceId::Buffer(buffer) = r { if let RenderResourceId::Buffer(buffer) = r {

6
crates/bevy_render/src/pipeline/pipeline_compiler.rs
View File

@ -1,7 +1,7 @@
use super::{state_descriptors::PrimitiveTopology, PipelineDescriptor, VertexBufferDescriptors}; use super::{state_descriptors::PrimitiveTopology, PipelineDescriptor, VertexBufferDescriptors};
use crate::{ use crate::{
draw::RenderPipelines, draw::RenderPipelines,
renderer::{RenderResourceContext, RenderResources}, renderer::RenderResourceContext,
shader::{Shader, ShaderSource}, shader::{Shader, ShaderSource},
}; };
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, Handle};
@ -214,10 +214,10 @@ pub fn compile_pipelines_system(
mut shaders: ResMut<Assets<Shader>>, mut shaders: ResMut<Assets<Shader>>,
mut pipelines: ResMut<Assets<PipelineDescriptor>>, mut pipelines: ResMut<Assets<PipelineDescriptor>>,
vertex_buffer_descriptors: Res<VertexBufferDescriptors>, vertex_buffer_descriptors: Res<VertexBufferDescriptors>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
query: &mut Query<Write<RenderPipelines>>, query: &mut Query<Write<RenderPipelines>>,
) { ) {
let render_resource_context = &*render_resources.context; let render_resource_context = &**render_resource_context;
// TODO: only update when RenderPipelines is changed // TODO: only update when RenderPipelines is changed
for mut render_pipelines in query.iter_mut(world) { for mut render_pipelines in query.iter_mut(world) {

14
crates/bevy_render/src/render_graph/nodes/camera_node.rs
View File

@ -1,9 +1,7 @@
use crate::{ use crate::{
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode}, render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{ render_resource::{BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings},
BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, renderer::{RenderResourceContext, RenderContext},
},
renderer::{RenderContext, RenderResources},
Camera, Camera,
}; };
use bevy_core::bytes::AsBytes; use bevy_core::bytes::AsBytes;
@ -48,15 +46,15 @@ impl SystemNode for CameraNode {
let mut command_queue = self.command_queue.clone(); let mut command_queue = self.command_queue.clone();
let uniform_name = self.uniform_name.clone(); let uniform_name = self.uniform_name.clone();
(move |world: &mut SubWorld, (move |world: &mut SubWorld,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
// PERF: this write on RenderResourceAssignments will prevent this system from running in parallel // PERF: this write on RenderResourceAssignments will prevent this system from running in parallel
// with other systems that do the same // with other systems that do the same
mut render_resource_bindings: ResMut<RenderResourceBindings>, mut render_resource_bindings: ResMut<RenderResourceBindings>,
query: &mut Query<(Read<Camera>, Read<Transform>)>| { query: &mut Query<(Read<Camera>, Read<Transform>)>| {
let render_resources = &render_resources.context; let render_resource_context = &**render_resource_context;
if camera_buffer.is_none() { if camera_buffer.is_none() {
let size = std::mem::size_of::<[[f32; 4]; 4]>(); 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, size,
buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM, buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
..Default::default() ..Default::default()
@ -79,7 +77,7 @@ impl SystemNode for CameraNode {
let camera_matrix: [f32; 16] = let camera_matrix: [f32; 16] =
(camera.view_matrix * transform.value).to_cols_array(); (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 { BufferInfo {
size: matrix_size, size: matrix_size,
buffer_usage: BufferUsage::COPY_SRC, buffer_usage: BufferUsage::COPY_SRC,

34
crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
View File

@ -5,7 +5,7 @@ use crate::{
self, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings, self, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
RenderResourceBindingsId, RenderResourceHints, RenderResourceBindingsId, RenderResourceHints,
}, },
renderer::{RenderContext, RenderResourceContext, RenderResources}, renderer::{RenderContext, RenderResourceContext},
texture, texture,
}; };
@ -196,7 +196,7 @@ where
&mut self, &mut self,
uniforms: &T, uniforms: &T,
dynamic_uniforms: bool, dynamic_uniforms: bool,
render_resources: &dyn RenderResourceContext, render_resource_context: &dyn RenderResourceContext,
render_resource_bindings: &mut RenderResourceBindings, render_resource_bindings: &mut RenderResourceBindings,
staging_buffer: &mut [u8], staging_buffer: &mut [u8],
) { ) {
@ -209,8 +209,8 @@ where
let range = 0..size as u64; let range = 0..size as u64;
let (target_buffer, target_offset) = if dynamic_uniforms { let (target_buffer, target_offset) = if dynamic_uniforms {
let buffer = uniform_buffer_status.buffer.unwrap(); let buffer = uniform_buffer_status.buffer.unwrap();
let index = uniform_buffer_status let index =
.get_or_assign_index(render_resource_bindings.id); uniform_buffer_status.get_or_assign_index(render_resource_bindings.id);
render_resource_bindings.set( render_resource_bindings.set(
render_resource_name, render_resource_name,
RenderResourceBinding::Buffer { RenderResourceBinding::Buffer {
@ -225,13 +225,11 @@ where
} else { } else {
let mut matching_buffer = None; let mut matching_buffer = None;
let mut buffer_to_remove = None; let mut buffer_to_remove = None;
if let Some(binding) = if let Some(binding) = render_resource_bindings.get(render_resource_name) {
render_resource_bindings.get(render_resource_name)
{
let buffer_id = binding.get_buffer().unwrap(); let buffer_id = binding.get_buffer().unwrap();
if let Some(BufferInfo { if let Some(BufferInfo {
size: current_size, .. size: current_size, ..
}) = render_resources.get_buffer_info(buffer_id) }) = render_resource_context.get_buffer_info(buffer_id)
{ {
if size == current_size { if size == current_size {
matching_buffer = Some(buffer_id); matching_buffer = Some(buffer_id);
@ -243,7 +241,7 @@ where
} }
if let Some(buffer) = buffer_to_remove { 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 { 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, size,
buffer_usage: BufferUsage::COPY_DST | usage, buffer_usage: BufferUsage::COPY_DST | usage,
..Default::default() ..Default::default()
@ -373,10 +371,10 @@ where
let dynamic_uniforms = self.dynamic_uniforms; let dynamic_uniforms = self.dynamic_uniforms;
// TODO: maybe run "update" here // TODO: maybe run "update" here
(move |world: &mut SubWorld, (move |world: &mut SubWorld,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
query: &mut Query<(Read<T>, Read<Draw>, Write<RenderPipelines>)>| { query: &mut Query<(Read<T>, Read<Draw>, Write<RenderPipelines>)>| {
let render_resource_context = &*render_resources.context;
let render_resource_context = &** render_resource_context;
uniform_buffer_arrays.reset_changed_item_counts(); uniform_buffer_arrays.reset_changed_item_counts();
// update uniforms info // update uniforms info
for (uniforms, draw, _render_pipelines) in query.iter_mut(world) { for (uniforms, draw, _render_pipelines) in query.iter_mut(world) {
@ -424,7 +422,7 @@ where
size: staging_buffer_size, size: staging_buffer_size,
..Default::default() ..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) { for (uniforms, draw, mut render_pipelines) in query.iter_mut(world) {
if !draw.is_visible { if !draw.is_visible {
return; return;
@ -505,9 +503,9 @@ where
(move |world: &mut SubWorld, (move |world: &mut SubWorld,
assets: Res<Assets<T>>, assets: Res<Assets<T>>,
// asset_events: Res<Events<AssetEvent<T>>>, // asset_events: Res<Events<AssetEvent<T>>>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
query: &mut Query<(Read<Handle<T>>, Read<Draw>, Write<RenderPipelines>)>| { query: &mut Query<(Read<Handle<T>>, Read<Draw>, Write<RenderPipelines>)>| {
let render_resource_context = &*render_resources.context; let render_resource_context = &**render_resource_context;
uniform_buffer_arrays.reset_changed_item_counts(); uniform_buffer_arrays.reset_changed_item_counts();
let modified_assets = assets let modified_assets = assets
@ -575,7 +573,7 @@ where
size: staging_buffer_size, size: staging_buffer_size,
..Default::default() ..Default::default()
}, },
&mut |mut staging_buffer, _render_resources| { &mut |mut staging_buffer, _render_resource_context| {
for asset_handle in modified_assets.iter() { for asset_handle in modified_assets.iter() {
let asset = assets.get(&asset_handle).expect(EXPECT_ASSET_MESSAGE); let asset = assets.get(&asset_handle).expect(EXPECT_ASSET_MESSAGE);
let mut render_resource_bindings = asset_render_resource_bindings 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) { for (asset_handle, _draw, mut render_pipelines) in query.iter_mut(world) {
if let Some(asset_bindings) = if let Some(asset_bindings) = asset_render_resource_bindings.get(&asset_handle) {
asset_render_resource_bindings.get(&asset_handle)
{
render_pipelines render_pipelines
.render_resource_bindings .render_resource_bindings
.extend(asset_bindings); .extend(asset_bindings);

6
crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
View File

@ -54,7 +54,7 @@ impl Node for WindowSwapChainNode {
.expect("Received window resized event for non-existent window"), .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 // create window swapchain when window is resized or created
if self if self
@ -66,10 +66,10 @@ impl Node for WindowSwapChainNode {
.find_latest(&window_resized_events, |e| e.id == window.id) .find_latest(&window_resized_events, |e| e.id == window.id)
.is_some() .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)); output.set(WINDOW_TEXTURE, RenderResourceId::Texture(swap_chain_texture));
} }
} }

6
crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
View File

@ -66,14 +66,14 @@ impl Node for WindowTextureNode {
.find_latest(&window_resized_events, |e| e.id == window.id) .find_latest(&window_resized_events, |e| e.id == window.id)
.is_some() .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) { 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.width = window.width;
self.descriptor.size.height = window.height; 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)); output.set(WINDOW_TEXTURE, RenderResourceId::Texture(texture_resource));
} }
} }

14
crates/bevy_render/src/render_resource/systems.rs
View File

@ -1,10 +1,10 @@
use bevy_asset::Assets;
use crate::{ use crate::{
draw::RenderPipelines, draw::RenderPipelines,
pipeline::{PipelineCompiler, PipelineDescriptor}, pipeline::{PipelineCompiler, PipelineDescriptor},
render_resource::{RenderResourceBindings, BindGroupStatus}, render_resource::{BindGroupStatus, RenderResourceBindings},
renderer::{RenderResourceContext, RenderResources}, renderer::RenderResourceContext,
}; };
use bevy_asset::Assets;
use legion::prelude::*; use legion::prelude::*;
fn update_bind_groups( fn update_bind_groups(
@ -20,7 +20,7 @@ fn update_bind_groups(
.get_bind_group(id) .get_bind_group(id)
.expect("RenderResourceSet was just changed, so it should exist"); .expect("RenderResourceSet was just changed, so it should exist");
render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group); 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 // 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() // removal of global context.clear_bind_groups()
// PERF: see above // PERF: see above
@ -29,7 +29,7 @@ fn update_bind_groups(
.get_bind_group(id) .get_bind_group(id)
.expect("RenderResourceSet was just changed, so it should exist"); .expect("RenderResourceSet was just changed, so it should exist");
render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group); render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group);
}, }
BindGroupStatus::NoMatch => { BindGroupStatus::NoMatch => {
// ignore unchanged / unmatched render resource sets // ignore unchanged / unmatched render resource sets
} }
@ -41,11 +41,11 @@ pub fn bind_groups_system(
world: &mut SubWorld, world: &mut SubWorld,
pipelines: Res<Assets<PipelineDescriptor>>, pipelines: Res<Assets<PipelineDescriptor>>,
pipeline_compiler: Res<PipelineCompiler>, pipeline_compiler: Res<PipelineCompiler>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
mut render_resource_bindings: ResMut<RenderResourceBindings>, mut render_resource_bindings: ResMut<RenderResourceBindings>,
query: &mut Query<Write<RenderPipelines>>, query: &mut Query<Write<RenderPipelines>>,
) { ) {
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() { for compiled_pipeline_handle in pipeline_compiler.iter_all_compiled_pipelines() {
let pipeline = pipelines.get(compiled_pipeline_handle).unwrap(); let pipeline = pipelines.get(compiled_pipeline_handle).unwrap();
update_bind_groups( update_bind_groups(

15
crates/bevy_render/src/renderer/render_resource_context.rs
View File

@ -8,21 +8,6 @@ use bevy_asset::{Assets, Handle, HandleUntyped};
use bevy_window::{Window, WindowId}; use bevy_window::{Window, WindowId};
use downcast_rs::{impl_downcast, Downcast}; use downcast_rs::{impl_downcast, Downcast};
pub struct RenderResources {
pub context: Box<dyn RenderResourceContext>,
}
impl RenderResources {
pub fn new<T>(context: T) -> RenderResources
where
T: RenderResourceContext,
{
RenderResources {
context: Box::new(context),
}
}
}
pub trait RenderResourceContext: Downcast + Send + Sync + 'static { pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
fn create_swap_chain(&self, window: &Window); fn create_swap_chain(&self, window: &Window);
fn next_swap_chain_texture(&self, window_id: WindowId) -> TextureId; fn next_swap_chain_texture(&self, window_id: WindowId) -> TextureId;

44
crates/bevy_render/src/texture/texture.rs
View File

@ -1,7 +1,7 @@
use super::{SamplerDescriptor, TextureDescriptor}; use super::{SamplerDescriptor, TextureDescriptor};
use crate::{ use crate::{
renderer::{RenderResourceContext, RenderResources}, render_resource::{RenderResource, RenderResourceId, ResourceInfo},
render_resource::{ResourceInfo, RenderResource, RenderResourceId}, renderer::RenderResourceContext,
}; };
use bevy_app::{EventReader, Events}; use bevy_app::{EventReader, Events};
use bevy_asset::{AssetEvent, Assets, Handle}; use bevy_asset::{AssetEvent, Assets, Handle};
@ -47,11 +47,11 @@ impl Texture {
pub fn texture_resource_system( pub fn texture_resource_system(
mut state: ResMut<TextureResourceSystemState>, mut state: ResMut<TextureResourceSystemState>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
textures: Res<Assets<Texture>>, textures: Res<Assets<Texture>>,
texture_events: Res<Events<AssetEvent<Texture>>>, texture_events: Res<Events<AssetEvent<Texture>>>,
) { ) {
let render_resources = &*render_resources.context; let render_resource_context = &**render_resource_context;
let mut changed_textures = HashSet::new(); let mut changed_textures = HashSet::new();
for event in state.event_reader.iter(&texture_events) { for event in state.event_reader.iter(&texture_events) {
match event { match event {
@ -60,10 +60,10 @@ impl Texture {
} }
AssetEvent::Modified { handle } => { AssetEvent::Modified { handle } => {
changed_textures.insert(*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 } => { 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 // if texture was modified and removed in the same update, ignore the modification
// events are ordered so future modification events are ok // events are ordered so future modification events are ok
changed_textures.remove(handle); changed_textures.remove(handle);
@ -74,17 +74,17 @@ impl Texture {
for texture_handle in changed_textures.iter() { for texture_handle in changed_textures.iter() {
if let Some(texture) = textures.get(texture_handle) { if let Some(texture) = textures.get(texture_handle) {
let texture_descriptor: TextureDescriptor = texture.into(); 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_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, *texture_handle,
RenderResourceId::Texture(texture_resource), RenderResourceId::Texture(texture_resource),
TEXTURE_ASSET_INDEX, TEXTURE_ASSET_INDEX,
); );
render_resources.set_asset_resource( render_resource_context.set_asset_resource(
*texture_handle, *texture_handle,
RenderResourceId::Sampler(sampler_resource), RenderResourceId::Sampler(sampler_resource),
SAMPLER_ASSET_INDEX, SAMPLER_ASSET_INDEX,
@ -94,16 +94,20 @@ impl Texture {
} }
fn remove_current_texture_resources( fn remove_current_texture_resources(
render_resources: &dyn RenderResourceContext, render_resource_context: &dyn RenderResourceContext,
handle: Handle<Texture>, handle: Handle<Texture>,
) { ) {
if let Some(RenderResourceId::Texture(resource)) = render_resources.get_asset_resource(handle, TEXTURE_ASSET_INDEX) { if let Some(RenderResourceId::Texture(resource)) =
render_resources.remove_texture(resource); render_resource_context.get_asset_resource(handle, TEXTURE_ASSET_INDEX)
render_resources.remove_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) { if let Some(RenderResourceId::Sampler(resource)) =
render_resources.remove_sampler(resource); render_resource_context.get_asset_resource(handle, SAMPLER_ASSET_INDEX)
render_resources.remove_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<Handle<Texture>> {
fn resource_info(&self) -> Option<ResourceInfo> { fn resource_info(&self) -> Option<ResourceInfo> {
self.map(|_texture| ResourceInfo::Texture(None)) 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<usize> { fn buffer_byte_len(&self) -> Option<usize> {
None None
} }
@ -131,8 +134,7 @@ impl RenderResource for Handle<Texture> {
fn resource_info(&self) -> Option<ResourceInfo> { fn resource_info(&self) -> Option<ResourceInfo> {
Some(ResourceInfo::Texture(None)) 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<usize> { fn buffer_byte_len(&self) -> Option<usize> {
None None
} }

4
crates/bevy_ui/src/widget/label.rs
View File

@ -3,7 +3,7 @@ use bevy_render::{
draw::Draw, draw::Draw,
pipeline::PipelineDescriptor, pipeline::PipelineDescriptor,
render_resource::{RenderResourceBindings, SharedBuffers}, render_resource::{RenderResourceBindings, SharedBuffers},
renderer::RenderResources, renderer::RenderResourceContext,
texture::Texture, texture::Texture,
Color, Color,
}; };
@ -80,7 +80,7 @@ impl Label {
pub fn draw_label_system( pub fn draw_label_system(
_pipelines: Res<Assets<PipelineDescriptor>>, _pipelines: Res<Assets<PipelineDescriptor>>,
_render_resource_bindings: Res<RenderResourceBindings>, _render_resource_bindings: Res<RenderResourceBindings>,
_render_resources: Res<RenderResources>, _render_resource_context: Res<Box<dyn RenderResourceContext>>,
_shared_buffers: Res<SharedBuffers>, _shared_buffers: Res<SharedBuffers>,
_fonts: Res<Assets<Font>>, _fonts: Res<Assets<Font>>,
_font_atlas_sets: Res<Assets<FontAtlasSet>>, _font_atlas_sets: Res<Assets<FontAtlasSet>>,

7
crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
View File

@ -1,7 +1,7 @@
use crate::renderer::WgpuRenderResourceContext; use crate::renderer::WgpuRenderResourceContext;
use bevy_app::{AppBuilder, AppPlugin}; use bevy_app::{AppBuilder, AppPlugin};
use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics}; use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_render::renderer::RenderResources; use bevy_render::renderer::RenderResourceContext;
use legion::prelude::{IntoSystem, Res, ResMut}; use legion::prelude::{IntoSystem, Res, ResMut};
#[derive(Default)] #[derive(Default)]
@ -94,10 +94,9 @@ impl WgpuResourceDiagnosticsPlugin {
pub fn diagnostic_system( pub fn diagnostic_system(
mut diagnostics: ResMut<Diagnostics>, mut diagnostics: ResMut<Diagnostics>,
render_resources: Res<RenderResources>, render_resource_context: Res<Box<dyn RenderResourceContext>>,
) { ) {
let render_resource_context = render_resources let render_resource_context = render_resource_context
.context
.downcast_ref::<WgpuRenderResourceContext>() .downcast_ref::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();

7
crates/bevy_wgpu/src/lib.rs
View File

@ -10,10 +10,7 @@ pub use wgpu_renderer::*;
pub use wgpu_resources::*; pub use wgpu_resources::*;
use bevy_app::{AppBuilder, AppPlugin}; use bevy_app::{AppBuilder, AppPlugin};
use bevy_render::{ use bevy_render::{renderer::RenderResourceContext, render_resource::{free_shared_buffers_system, SharedBuffers}};
render_resource::{free_shared_buffers_system, SharedBuffers},
renderer::RenderResources,
};
use legion::prelude::*; use legion::prelude::*;
use renderer::WgpuRenderResourceContext; 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) { pub fn wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut World, &mut Resources) {
let mut wgpu_renderer = pollster::block_on(WgpuRenderer::new()); let mut wgpu_renderer = pollster::block_on(WgpuRenderer::new());
resources.insert(RenderResources::new(WgpuRenderResourceContext::new( resources.insert::<Box<dyn RenderResourceContext>>(Box::new(WgpuRenderResourceContext::new(
wgpu_renderer.device.clone(), wgpu_renderer.device.clone(),
))); )));
resources.insert(SharedBuffers::new(Box::new( resources.insert(SharedBuffers::new(Box::new(

16
crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
View File

@ -51,14 +51,14 @@ impl LazyCommandEncoder {
pub struct WgpuRenderContext { pub struct WgpuRenderContext {
pub device: Arc<wgpu::Device>, pub device: Arc<wgpu::Device>,
pub command_encoder: LazyCommandEncoder, pub command_encoder: LazyCommandEncoder,
pub render_resources: WgpuRenderResourceContext, pub render_resource_context: WgpuRenderResourceContext,
} }
impl WgpuRenderContext { impl WgpuRenderContext {
pub fn new(device: Arc<wgpu::Device>, resources: WgpuRenderResourceContext) -> Self { pub fn new(device: Arc<wgpu::Device>, resources: WgpuRenderResourceContext) -> Self {
WgpuRenderContext { WgpuRenderContext {
device, device,
render_resources: resources, render_resource_context: resources,
command_encoder: LazyCommandEncoder::default(), command_encoder: LazyCommandEncoder::default(),
} }
} }
@ -79,7 +79,7 @@ impl RenderContext for WgpuRenderContext {
destination_offset: u64, destination_offset: u64,
size: 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), self.command_encoder.get_or_create(&self.device),
source_buffer, source_buffer,
source_offset, source_offset,
@ -99,7 +99,7 @@ impl RenderContext for WgpuRenderContext {
destination_mip_level: u32, destination_mip_level: u32,
size: Extent3d, 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), self.command_encoder.get_or_create(&self.device),
source_buffer, source_buffer,
source_offset, source_offset,
@ -112,10 +112,10 @@ impl RenderContext for WgpuRenderContext {
} }
fn resources(&self) -> &dyn RenderResourceContext { fn resources(&self) -> &dyn RenderResourceContext {
&self.render_resources &self.render_resource_context
} }
fn resources_mut(&mut self) -> &mut dyn RenderResourceContext { fn resources_mut(&mut self) -> &mut dyn RenderResourceContext {
&mut self.render_resources &mut self.render_resource_context
} }
fn begin_pass( fn begin_pass(
@ -127,7 +127,7 @@ impl RenderContext for WgpuRenderContext {
if !self.command_encoder.is_some() { if !self.command_encoder.is_some() {
self.command_encoder.create(&self.device); 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 refs = resource_lock.refs();
let mut encoder = self.command_encoder.take().unwrap(); let mut encoder = self.command_encoder.take().unwrap();
{ {
@ -140,7 +140,7 @@ impl RenderContext for WgpuRenderContext {
let mut wgpu_render_pass = WgpuRenderPass { let mut wgpu_render_pass = WgpuRenderPass {
render_pass, render_pass,
render_context: self, render_context: self,
render_resources: refs, wgpu_resources: refs,
pipeline_descriptor: None, pipeline_descriptor: None,
}; };

13
crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
View File

@ -1,7 +1,7 @@
use super::{WgpuRenderContext, WgpuRenderResourceContext}; use super::{WgpuRenderContext, WgpuRenderResourceContext};
use bevy_render::{ use bevy_render::{
render_graph::{Edge, NodeId, ResourceSlots, StageBorrow}, render_graph::{Edge, NodeId, ResourceSlots, StageBorrow},
renderer::RenderResources, renderer::RenderResourceContext,
}; };
use legion::prelude::{Resources, World}; use legion::prelude::{Resources, World};
use std::{ use std::{
@ -22,9 +22,10 @@ impl WgpuRenderGraphExecutor {
queue: &mut wgpu::Queue, queue: &mut wgpu::Queue,
stages: &mut [StageBorrow], stages: &mut [StageBorrow],
) { ) {
let mut render_resources = resources.get_mut::<RenderResources>().unwrap(); let mut render_resource_context = resources
let wgpu_render_resources = render_resources .get_mut::<Box<dyn RenderResourceContext>>()
.context .unwrap();
let render_resource_context = render_resource_context
.downcast_mut::<WgpuRenderResourceContext>() .downcast_mut::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();
let node_outputs: Arc<RwLock<HashMap<NodeId, ResourceSlots>>> = Default::default(); let node_outputs: Arc<RwLock<HashMap<NodeId, ResourceSlots>>> = Default::default();
@ -41,10 +42,10 @@ impl WgpuRenderGraphExecutor {
let world = &*world; let world = &*world;
actual_thread_count += 1; actual_thread_count += 1;
let device = device.clone(); 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(); let node_outputs = node_outputs.clone();
// s.spawn(move |_| { // 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 job in jobs_chunk.iter_mut() {
for node_state in job.node_states.iter_mut() { for node_state in job.node_states.iter_mut() {
// bind inputs from connected node outputs // bind inputs from connected node outputs

10
crates/bevy_wgpu/src/wgpu_render_pass.rs
View File

@ -11,7 +11,7 @@ use std::ops::Range;
pub struct WgpuRenderPass<'a> { pub struct WgpuRenderPass<'a> {
pub render_pass: wgpu::RenderPass<'a>, pub render_pass: wgpu::RenderPass<'a>,
pub render_context: &'a WgpuRenderContext, pub render_context: &'a WgpuRenderContext,
pub render_resources: WgpuResourceRefs<'a>, pub wgpu_resources: WgpuResourceRefs<'a>,
pub pipeline_descriptor: Option<&'a PipelineDescriptor>, 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) { 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 self.render_pass
.set_vertex_buffer(start_slot, buffer.slice(offset..)); .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) { 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..)); self.render_pass.set_index_buffer(buffer.slice(offset..));
} }
@ -57,7 +57,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> {
dynamic_uniform_indices: Option<&[u32]>, dynamic_uniform_indices: Option<&[u32]>,
) { ) {
if let Some(bind_group_info) = self if let Some(bind_group_info) = self
.render_resources .wgpu_resources
.bind_groups .bind_groups
.get(&bind_group_descriptor) .get(&bind_group_descriptor)
{ {
@ -83,7 +83,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> {
} }
fn set_pipeline(&mut self, pipeline_handle: Handle<PipelineDescriptor>) { fn set_pipeline(&mut self, pipeline_handle: Handle<PipelineDescriptor>) {
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", "Attempted to use a pipeline that does not exist in this RenderPass's RenderContext",
); );
self.render_pass.set_pipeline(pipeline); self.render_pass.set_pipeline(pipeline);

17
crates/bevy_wgpu/src/wgpu_renderer.rs
View File

@ -2,7 +2,7 @@ use crate::renderer::{WgpuRenderGraphExecutor, WgpuRenderResourceContext};
use bevy_app::{EventReader, Events}; use bevy_app::{EventReader, Events};
use bevy_render::{ use bevy_render::{
render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager}, render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager},
renderer::RenderResources, renderer::RenderResourceContext,
}; };
use bevy_window::{WindowCreated, WindowResized, Windows}; use bevy_window::{WindowCreated, WindowResized, Windows};
use legion::prelude::*; use legion::prelude::*;
@ -54,9 +54,10 @@ impl WgpuRenderer {
} }
pub fn handle_window_created_events(&mut self, resources: &Resources) { pub fn handle_window_created_events(&mut self, resources: &Resources) {
let mut render_resources = resources.get_mut::<RenderResources>().unwrap(); let mut render_resource_context = resources
let render_resource_context = render_resources .get_mut::<Box<dyn RenderResourceContext>>()
.context .unwrap();
let render_resource_context = render_resource_context
.downcast_mut::<WgpuRenderResourceContext>() .downcast_mut::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();
let windows = resources.get::<Windows>().unwrap(); let windows = resources.get::<Windows>().unwrap();
@ -102,10 +103,8 @@ impl WgpuRenderer {
self.handle_window_created_events(resources); self.handle_window_created_events(resources);
self.run_graph(world, resources); self.run_graph(world, resources);
let render_resource_context = resources.get::<RenderResources>().unwrap(); let render_resource_context = resources.get::<Box<dyn RenderResourceContext>>().unwrap();
render_resource_context render_resource_context.drop_all_swap_chain_textures();
.context render_resource_context.clear_bind_groups();
.drop_all_swap_chain_textures();
render_resource_context.context.clear_bind_groups();
} }
} }