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

cargo fmt

Browse Source
This commit is contained in:
Carter Anderson 2020-05-01 01:50:07 -07:00
parent 4315455859
commit 368a1b8815
5 changed files with 98 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/bevy_app/src/plugin.rs
View File

@ -19,4 +19,4 @@ pub fn load_plugin(path: &str) -> (Library, Box<dyn AppPlugin>) {
let plugin = Box::from_raw(func()); let plugin = Box::from_raw(func());
(lib, plugin) (lib, plugin)
} }
} }

6
crates/bevy_app/src/schedule_plan.rs
View File

@ -1,6 +1,10 @@
use crate::System; use crate::System;
use legion::prelude::Schedule; use legion::prelude::Schedule;
use std::{cmp::Ordering, collections::{HashSet, HashMap}, borrow::Cow}; use std::{
borrow::Cow,
cmp::Ordering,
collections::{HashMap, HashSet},
};
#[derive(Default)] #[derive(Default)]
pub struct SchedulePlan { pub struct SchedulePlan {

4
crates/bevy_legion/legion_systems/src/system.rs
View File

@ -772,9 +772,7 @@ impl SystemId {
} }
} }
pub fn name(&self) -> Cow<'static, str> { pub fn name(&self) -> Cow<'static, str> { self.name.clone() }
self.name.clone()
}
} }
impl std::fmt::Display for SystemId { impl std::fmt::Display for SystemId {

2
crates/bevy_pbr/src/lib.rs
View File

@ -11,8 +11,8 @@ pub use forward_pbr_render_graph::*;
use bevy_app::{stage, AppBuilder, AppPlugin}; use bevy_app::{stage, AppBuilder, AppPlugin};
use bevy_asset::AssetStorage; use bevy_asset::AssetStorage;
use bevy_render::{render_graph::RenderGraph, shader}; use bevy_render::{render_graph::RenderGraph, shader};
use material::StandardMaterial;
use legion::prelude::IntoSystem; use legion::prelude::IntoSystem;
use material::StandardMaterial;
#[derive(Default)] #[derive(Default)]
pub struct PbrPlugin; pub struct PbrPlugin;

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

@ -432,41 +432,64 @@ where
let mut staging_buffer_resource = None; let mut staging_buffer_resource = None;
initialize_vertex_buffer_descriptor::<T>(&mut vertex_buffer_descriptors); initialize_vertex_buffer_descriptor::<T>(&mut vertex_buffer_descriptors);
// TODO: maybe run "update" here // TODO: maybe run "update" here
SystemBuilder::new(format!("uniform_resource_provider::<{}>", std::any::type_name::<T>())) SystemBuilder::new(format!(
.read_resource::<AssetStorage<Texture>>() "uniform_resource_provider::<{}>",
.read_resource::<GlobalRenderResourceContext>() std::any::type_name::<T>()
// 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()) .read_resource::<AssetStorage<Texture>>()
.with_query(<(Read<T>, Write<Renderable>)>::query()) .read_resource::<GlobalRenderResourceContext>()
.build( // TODO: this write on RenderResourceAssignments will prevent this system from running in parallel with other systems that do the same
move |_, .with_query(<(Read<T>, Read<Renderable>)>::query())
world, .with_query(<(Read<T>, Write<Renderable>)>::query())
(textures, global_render_resource_context), .build(
(read_uniform_query, write_uniform_query)| { move |_,
let render_resource_context = &*global_render_resource_context.context; world,
if let Some(staging_buffer_resource) = staging_buffer_resource { (textures, global_render_resource_context),
render_resource_context.remove_buffer(staging_buffer_resource); (read_uniform_query, write_uniform_query)| {
} let render_resource_context = &*global_render_resource_context.context;
staging_buffer_resource = None; if let Some(staging_buffer_resource) = staging_buffer_resource {
render_resource_context.remove_buffer(staging_buffer_resource);
}
staging_buffer_resource = None;
uniform_buffer_arrays.reset_new_item_counts(); uniform_buffer_arrays.reset_new_item_counts();
// update uniforms info // update uniforms info
for (uniforms, renderable) in read_uniform_query.iter(world) { for (uniforms, renderable) in read_uniform_query.iter(world) {
if !renderable.is_visible { if !renderable.is_visible {
return; return;
}
if renderable.is_instanced {
panic!("instancing not currently supported");
} else {
uniform_buffer_arrays.increment_uniform_counts(&uniforms);
}
} }
uniform_buffer_arrays if renderable.is_instanced {
.setup_buffer_arrays(render_resource_context, dynamic_uniforms); panic!("instancing not currently supported");
let staging_buffer_size = uniform_buffer_arrays.update_staging_buffer_offsets(); } else {
uniform_buffer_arrays.increment_uniform_counts(&uniforms);
}
}
uniform_buffer_arrays
.setup_buffer_arrays(render_resource_context, dynamic_uniforms);
let staging_buffer_size = uniform_buffer_arrays.update_staging_buffer_offsets();
for (uniforms, mut renderable) in write_uniform_query.iter_mut(world) {
if !renderable.is_visible {
return;
}
if renderable.is_instanced {
panic!("instancing not currently supported");
} else {
setup_uniform_texture_resources::<T>(
&uniforms,
&mut command_queue,
textures,
render_resource_context,
&mut renderable.render_resource_assignments,
)
}
}
if staging_buffer_size == 0 {
let mut staging_buffer: [u8; 0] = [];
for (uniforms, mut renderable) in write_uniform_query.iter_mut(world) { for (uniforms, mut renderable) in write_uniform_query.iter_mut(world) {
if !renderable.is_visible { if !renderable.is_visible {
return; return;
@ -475,74 +498,50 @@ where
if renderable.is_instanced { if renderable.is_instanced {
panic!("instancing not currently supported"); panic!("instancing not currently supported");
} else { } else {
setup_uniform_texture_resources::<T>( uniform_buffer_arrays.setup_uniform_buffer_resources(
&uniforms, &uniforms,
&mut command_queue, dynamic_uniforms,
textures,
render_resource_context, render_resource_context,
&mut renderable.render_resource_assignments, &mut renderable.render_resource_assignments,
) &mut staging_buffer,
);
} }
} }
} else {
if staging_buffer_size == 0 { let staging_buffer = render_resource_context.create_buffer_mapped(
let mut staging_buffer: [u8; 0] = []; BufferInfo {
for (uniforms, mut renderable) in write_uniform_query.iter_mut(world) { buffer_usage: BufferUsage::COPY_SRC,
if !renderable.is_visible { size: staging_buffer_size,
return; ..Default::default()
} },
&mut |mut staging_buffer, _render_resources| {
if renderable.is_instanced { for (uniforms, mut renderable) in write_uniform_query.iter_mut(world) {
panic!("instancing not currently supported"); if !renderable.is_visible {
} else { return;
uniform_buffer_arrays.setup_uniform_buffer_resources(
&uniforms,
dynamic_uniforms,
render_resource_context,
&mut renderable.render_resource_assignments,
&mut staging_buffer,
);
}
}
} else {
let staging_buffer = render_resource_context.create_buffer_mapped(
BufferInfo {
buffer_usage: BufferUsage::COPY_SRC,
size: staging_buffer_size,
..Default::default()
},
&mut |mut staging_buffer, _render_resources| {
for (uniforms, mut renderable) in
write_uniform_query.iter_mut(world)
{
if !renderable.is_visible {
return;
}
if renderable.is_instanced {
panic!("instancing not currently supported");
} else {
uniform_buffer_arrays.setup_uniform_buffer_resources(
&uniforms,
dynamic_uniforms,
render_resource_context,
&mut renderable.render_resource_assignments,
&mut staging_buffer,
);
}
} }
},
);
uniform_buffer_arrays.copy_staging_buffer_to_final_buffers( if renderable.is_instanced {
&mut command_queue, panic!("instancing not currently supported");
staging_buffer, } else {
); uniform_buffer_arrays.setup_uniform_buffer_resources(
&uniforms,
dynamic_uniforms,
render_resource_context,
&mut renderable.render_resource_assignments,
&mut staging_buffer,
);
}
}
},
);
staging_buffer_resource = Some(staging_buffer); uniform_buffer_arrays
} .copy_staging_buffer_to_final_buffers(&mut command_queue, staging_buffer);
},
) staging_buffer_resource = Some(staging_buffer);
}
},
)
} }
} }