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

rename GlobalRenderResourceContext to RenderResources

Browse Source
This commit is contained in:
Carter Anderson 2020-05-04 19:34:15 -07:00
parent 7560ecf9d8
commit 2fd7020646
11 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,7 +1,7 @@
use bevy_render::{ use bevy_render::{
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode}, render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments}, render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderContext}, renderer::{RenderResources, RenderContext},
}; };
use crate::light::{Light, LightRaw}; use crate::light::{Light, LightRaw};
@ -53,7 +53,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;
SystemBuilder::new("light_node") SystemBuilder::new("light_node")
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
// 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
.write_resource::<RenderResourceAssignments>() .write_resource::<RenderResourceAssignments>()
.with_query(<(Read<Light>, Read<LocalToWorld>, Read<Translation>)>::query()) .with_query(<(Read<Light>, Read<LocalToWorld>, Read<Translation>)>::query())

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

@ -4,7 +4,7 @@ use crate::{
VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
}, },
render_resource::{BufferInfo, BufferUsage, RenderResourceAssignments}, render_resource::{BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderResourceContext}, renderer::{RenderResources, RenderResourceContext},
shader::AsUniforms, shader::AsUniforms,
Renderable, Vertex, Renderable, Vertex,
}; };
@ -380,7 +380,7 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
let vertex_buffer_descriptor = Vertex::get_vertex_buffer_descriptor().unwrap(); let vertex_buffer_descriptor = Vertex::get_vertex_buffer_descriptor().unwrap();
vertex_buffer_descriptors.set(vertex_buffer_descriptor.clone()); vertex_buffer_descriptors.set(vertex_buffer_descriptor.clone());
SystemBuilder::new("mesh_resource_provider") SystemBuilder::new("mesh_resource_provider")
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
.read_resource::<AssetStorage<Mesh>>() .read_resource::<AssetStorage<Mesh>>()
.with_query(<(Read<Handle<Mesh>>, Write<Renderable>)>::query()) .with_query(<(Read<Handle<Mesh>>, Write<Renderable>)>::query())
.build( .build(

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

@ -6,7 +6,7 @@ use crate::{
render_resource::{ render_resource::{
BufferInfo, RenderResourceAssignments, RenderResourceAssignmentsId, ResourceInfo, BufferInfo, RenderResourceAssignments, RenderResourceAssignmentsId, ResourceInfo,
}, },
renderer::{GlobalRenderResourceContext, RenderResourceContext}, renderer::{RenderResources, RenderResourceContext},
shader::{Shader, ShaderSource}, shader::{Shader, ShaderSource},
Renderable, Renderable,
}; };
@ -289,8 +289,8 @@ pub fn update_shader_assignments(world: &mut World, resources: &Resources) {
let mut pipeline_compiler = resources.get_mut::<PipelineCompiler>().unwrap(); let mut pipeline_compiler = resources.get_mut::<PipelineCompiler>().unwrap();
let mut shader_storage = resources.get_mut::<AssetStorage<Shader>>().unwrap(); let mut shader_storage = resources.get_mut::<AssetStorage<Shader>>().unwrap();
let vertex_buffer_descriptors = resources.get::<VertexBufferDescriptors>().unwrap(); let vertex_buffer_descriptors = resources.get::<VertexBufferDescriptors>().unwrap();
let global_render_resource_context = let render_resources =
resources.get::<GlobalRenderResourceContext>().unwrap(); resources.get::<RenderResources>().unwrap();
let mut pipeline_descriptor_storage = resources let mut pipeline_descriptor_storage = resources
.get_mut::<AssetStorage<PipelineDescriptor>>() .get_mut::<AssetStorage<PipelineDescriptor>>()
.unwrap(); .unwrap();
@ -308,7 +308,7 @@ pub fn update_shader_assignments(world: &mut World, resources: &Resources) {
pipeline_compiler.update_shader_assignments( pipeline_compiler.update_shader_assignments(
&vertex_buffer_descriptors, &vertex_buffer_descriptors,
&mut shader_pipeline_assignments, &mut shader_pipeline_assignments,
&*global_render_resource_context.context, &*render_resources.context,
&mut pipeline_descriptor_storage, &mut pipeline_descriptor_storage,
&mut shader_storage, &mut shader_storage,
&renderable.pipelines, &renderable.pipelines,

4
crates/bevy_render/src/render_graph/nodes/camera2d_node.rs
View File

@ -5,7 +5,7 @@ use crate::{
camera::{ActiveCamera2d, Camera}, camera::{ActiveCamera2d, Camera},
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode}, render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments}, render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderContext}, renderer::{RenderResources, RenderContext},
}; };
use legion::prelude::*; use legion::prelude::*;
@ -36,7 +36,7 @@ impl SystemNode for Camera2dNode {
let mut window_resized_event_reader = resources.get_event_reader::<WindowResized>(); let mut window_resized_event_reader = resources.get_event_reader::<WindowResized>();
let mut command_queue = self.command_queue.clone(); let mut command_queue = self.command_queue.clone();
SystemBuilder::new("camera_2d_resource_provider") SystemBuilder::new("camera_2d_resource_provider")
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
// 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
.write_resource::<RenderResourceAssignments>() .write_resource::<RenderResourceAssignments>()
.read_resource::<Events<WindowResized>>() .read_resource::<Events<WindowResized>>()

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

@ -1,7 +1,7 @@
use crate::{ use crate::{
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode}, render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments}, render_resource::{resource_name, BufferInfo, BufferUsage, RenderResourceAssignments},
renderer::{GlobalRenderResourceContext, RenderContext}, renderer::{RenderResources, RenderContext},
ActiveCamera, Camera, ActiveCamera, Camera,
}; };
@ -36,7 +36,7 @@ impl SystemNode for CameraNode {
let mut window_resized_event_reader = resources.get_event_reader::<WindowResized>(); let mut window_resized_event_reader = resources.get_event_reader::<WindowResized>();
let mut command_queue = self.command_queue.clone(); let mut command_queue = self.command_queue.clone();
SystemBuilder::new("camera_resource_provider") SystemBuilder::new("camera_resource_provider")
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
// 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
.write_resource::<RenderResourceAssignments>() .write_resource::<RenderResourceAssignments>()
.read_resource::<Events<WindowResized>>() .read_resource::<Events<WindowResized>>()

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

@ -5,7 +5,7 @@ use crate::{
BufferArrayInfo, BufferInfo, BufferUsage, RenderResource, RenderResourceAssignments, BufferArrayInfo, BufferInfo, BufferUsage, RenderResource, RenderResourceAssignments,
RenderResourceAssignmentsId, ResourceInfo, RenderResourceAssignmentsId, ResourceInfo,
}, },
renderer::{GlobalRenderResourceContext, RenderContext, RenderResourceContext}, renderer::{RenderResources, RenderContext, RenderResourceContext},
shader::{AsUniforms, FieldBindType}, shader::{AsUniforms, FieldBindType},
texture, Renderable, texture, Renderable,
}; };
@ -437,16 +437,16 @@ where
std::any::type_name::<T>() std::any::type_name::<T>()
)) ))
.read_resource::<AssetStorage<Texture>>() .read_resource::<AssetStorage<Texture>>()
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
// 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
.with_query(<(Read<T>, Read<Renderable>)>::query()) .with_query(<(Read<T>, Read<Renderable>)>::query())
.with_query(<(Read<T>, Write<Renderable>)>::query()) .with_query(<(Read<T>, Write<Renderable>)>::query())
.build( .build(
move |_, move |_,
world, world,
(textures, global_render_resource_context), (textures, render_resources),
(read_uniform_query, write_uniform_query)| { (read_uniform_query, write_uniform_query)| {
let render_resource_context = &*global_render_resource_context.context; let render_resource_context = &*render_resources.context;
if let Some(staging_buffer_resource) = staging_buffer_resource { if let Some(staging_buffer_resource) = staging_buffer_resource {
render_resource_context.remove_buffer(staging_buffer_resource); render_resource_context.remove_buffer(staging_buffer_resource);
} }
@ -599,16 +599,16 @@ where
SystemBuilder::new("uniform_resource_provider") SystemBuilder::new("uniform_resource_provider")
.read_resource::<AssetStorage<T>>() .read_resource::<AssetStorage<T>>()
.read_resource::<AssetStorage<Texture>>() .read_resource::<AssetStorage<Texture>>()
.read_resource::<GlobalRenderResourceContext>() .read_resource::<RenderResources>()
// 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
.with_query(<(Read<Handle<T>>, Read<Renderable>)>::query()) .with_query(<(Read<Handle<T>>, Read<Renderable>)>::query())
.with_query(<(Read<Handle<T>>, Write<Renderable>)>::query()) .with_query(<(Read<Handle<T>>, Write<Renderable>)>::query())
.build( .build(
move |_, move |_,
world, world,
(assets, textures, global_render_resource_context), (assets, textures, render_resources),
(read_handle_query, write_handle_query)| { (read_handle_query, write_handle_query)| {
let render_resource_context = &*global_render_resource_context.context; let render_resource_context = &*render_resources.context;
if let Some(staging_buffer_resource) = staging_buffer_resource { if let Some(staging_buffer_resource) = staging_buffer_resource {
render_resource_context.remove_buffer(staging_buffer_resource); render_resource_context.remove_buffer(staging_buffer_resource);
} }

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

@ -7,16 +7,16 @@ use bevy_asset::{AssetStorage, 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 GlobalRenderResourceContext { pub struct RenderResources {
pub context: Box<dyn RenderResourceContext>, pub context: Box<dyn RenderResourceContext>,
} }
impl GlobalRenderResourceContext { impl RenderResources {
pub fn new<T>(context: T) -> GlobalRenderResourceContext pub fn new<T>(context: T) -> RenderResources
where where
T: RenderResourceContext, T: RenderResourceContext,
{ {
GlobalRenderResourceContext { RenderResources {
context: Box::new(context), context: Box::new(context),
} }
} }

6
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::GlobalRenderResourceContext; use bevy_render::renderer::RenderResources;
use legion::prelude::{IntoSystem, Resource, ResourceMut}; use legion::prelude::{IntoSystem, Resource, ResourceMut};
#[derive(Default)] #[derive(Default)]
@ -118,9 +118,9 @@ impl WgpuResourceDiagnosticsPlugin {
pub fn diagnostic_system( pub fn diagnostic_system(
mut diagnostics: ResourceMut<Diagnostics>, mut diagnostics: ResourceMut<Diagnostics>,
global_resource_context: Resource<GlobalRenderResourceContext>, render_resources: Resource<RenderResources>,
) { ) {
let render_resource_context = global_resource_context let render_resource_context = render_resources
.context .context
.downcast_ref::<WgpuRenderResourceContext>() .downcast_ref::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();

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

@ -10,7 +10,7 @@ pub use wgpu_renderer::*;
pub use wgpu_resources::*; pub use wgpu_resources::*;
use bevy_app::{AppBuilder, AppPlugin, Events}; use bevy_app::{AppBuilder, AppPlugin, Events};
use bevy_render::{renderer::GlobalRenderResourceContext, RENDER_STAGE}; use bevy_render::{renderer::RenderResources, RENDER_STAGE};
use bevy_window::{WindowCreated, WindowResized}; use bevy_window::{WindowCreated, WindowResized};
use legion::prelude::*; use legion::prelude::*;
use renderer::WgpuRenderResourceContext; use renderer::WgpuRenderResourceContext;
@ -34,7 +34,7 @@ pub fn wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut World, &
window_created_event.get_reader(), window_created_event.get_reader(),
)) ))
}; };
resources.insert(GlobalRenderResourceContext::new( resources.insert(RenderResources::new(
WgpuRenderResourceContext::new(wgpu_renderer.device.clone()), WgpuRenderResourceContext::new(wgpu_renderer.device.clone()),
)); ));
move |world, resources| { move |world, resources| {

10
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::GlobalRenderResourceContext, renderer::RenderResources,
}; };
use legion::prelude::{Resources, World}; use legion::prelude::{Resources, World};
use std::{collections::HashMap, sync::Arc}; use std::{collections::HashMap, sync::Arc};
@ -19,8 +19,8 @@ impl WgpuRenderGraphExecutor {
queue: &mut wgpu::Queue, queue: &mut wgpu::Queue,
stages: &mut [StageBorrow], stages: &mut [StageBorrow],
) { ) {
let mut global_context = resources.get_mut::<GlobalRenderResourceContext>().unwrap(); let mut render_resources = resources.get_mut::<RenderResources>().unwrap();
let render_resource_context = global_context let wgpu_render_resources = render_resources
.context .context
.downcast_mut::<WgpuRenderResourceContext>() .downcast_mut::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();
@ -39,10 +39,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 render_resource_context = render_resource_context.clone(); let wgpu_render_resources = wgpu_render_resources.clone();
s.spawn(move |_| { s.spawn(move |_| {
let mut render_context = let mut render_context =
WgpuRenderContext::new(device, render_resource_context); WgpuRenderContext::new(device, wgpu_render_resources);
let mut local_node_outputs = HashMap::new(); let mut local_node_outputs = HashMap::new();
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() {

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

@ -5,7 +5,7 @@ use bevy_app::{EventReader, Events};
use bevy_render::{ use bevy_render::{
pipeline::update_shader_assignments, pipeline::update_shader_assignments,
render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager}, render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager},
renderer::GlobalRenderResourceContext, renderer::RenderResources,
}; };
use bevy_window::{WindowCreated, WindowResized, Windows}; use bevy_window::{WindowCreated, WindowResized, Windows};
use legion::prelude::*; use legion::prelude::*;
@ -60,8 +60,8 @@ impl WgpuRenderer {
} }
pub fn handle_window_created_events(&mut self, resources: &Resources) { pub fn handle_window_created_events(&mut self, resources: &Resources) {
let mut global_context = resources.get_mut::<GlobalRenderResourceContext>().unwrap(); let mut render_resources = resources.get_mut::<RenderResources>().unwrap();
let render_resource_context = global_context let render_resource_context = render_resources
.context .context
.downcast_mut::<WgpuRenderResourceContext>() .downcast_mut::<WgpuRenderResourceContext>()
.unwrap(); .unwrap();
@ -127,7 +127,7 @@ 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::<GlobalRenderResourceContext>().unwrap(); let render_resource_context = resources.get::<RenderResources>().unwrap();
render_resource_context render_resource_context
.context .context
.drop_all_swap_chain_textures(); .drop_all_swap_chain_textures();