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

update ResourceProvider::update to actually use read-only world

Browse Source
This commit is contained in:
Carter Anderson 2020-04-11 20:32:25 -07:00
parent b9f4c0a53b
commit 77a6619bf4
7 changed files with 88 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bevy_render/src/render_resource/resource_provider.rs
View File

@ -10,8 +10,7 @@ pub trait ResourceProvider {
) {
}
// TODO: make this read-only
fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &mut World, _resources: &Resources) {
fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &World, _resources: &Resources) {
}
// TODO: remove this

54
bevy_render/src/render_resource/resource_providers/camera2d_resource_provider.rs
View File

@ -27,8 +27,28 @@ impl Camera2dResourceProvider {
window_resized_event_reader,
}
}
}
fn update_read_only(
impl ResourceProvider for Camera2dResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: std::mem::size_of::<[[f32; 4]; 4]>(),
buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::CAMERA2D, buffer);
self.camera_buffer = Some(buffer);
}
fn update(
&mut self,
render_context: &mut dyn RenderContext,
world: &World,
@ -43,8 +63,7 @@ impl Camera2dResourceProvider {
if let Some(_) = primary_window_resized_event {
let matrix_size = std::mem::size_of::<[[f32; 4]; 4]>();
for (camera, _) in <(Read<Camera>, Read<ActiveCamera2d>)>::query().iter(world)
{
for (camera, _) in <(Read<Camera>, Read<ActiveCamera2d>)>::query().iter(world) {
let camera_matrix: [[f32; 4]; 4] = camera.view_matrix.to_cols_array_2d();
if let Some(old_tmp_buffer) = self.tmp_buffer {
@ -73,32 +92,3 @@ impl Camera2dResourceProvider {
}
}
}
impl ResourceProvider for Camera2dResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: std::mem::size_of::<[[f32; 4]; 4]>(),
buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::CAMERA2D, buffer);
self.camera_buffer = Some(buffer);
}
fn update(
&mut self,
render_context: &mut dyn RenderContext,
world: &mut World,
resources: &Resources,
) {
self.update_read_only(render_context, world, resources);
}
}

56
bevy_render/src/render_resource/resource_providers/camera_resource_provider.rs
View File

@ -28,8 +28,33 @@ impl CameraResourceProvider {
window_resized_event_reader,
}
}
}
pub fn update_read_only(&mut self, world: &World, resources: &Resources, render_context: &mut dyn RenderContext) {
impl ResourceProvider for CameraResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: std::mem::size_of::<[[f32; 4]; 4]>(),
buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::CAMERA, buffer);
self.camera_buffer = Some(buffer);
}
fn update(
&mut self,
render_context: &mut dyn RenderContext,
world: &World,
resources: &Resources,
) {
let window_resized_events = resources.get::<Events<WindowResized>>().unwrap();
let primary_window_resized_event = window_resized_events
.iter(&mut self.window_resized_event_reader)
@ -70,32 +95,3 @@ impl CameraResourceProvider {
}
}
}
impl ResourceProvider for CameraResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: std::mem::size_of::<[[f32; 4]; 4]>(),
buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::CAMERA, buffer);
self.camera_buffer = Some(buffer);
}
fn update(
&mut self,
render_context: &mut dyn RenderContext,
world: &mut World,
resources: &Resources,
) {
self.update_read_only(world, resources, render_context);
}
}

10
bevy_render/src/render_resource/resource_providers/frame_texture_resource_provider.rs
View File

@ -21,8 +21,10 @@ impl FrameTextureResourceProvider {
height: 0,
}
}
}
pub fn update(&mut self, render_context: &mut dyn RenderContext, resources: &Resources) {
impl ResourceProvider for FrameTextureResourceProvider {
fn update(&mut self, render_context: &mut dyn RenderContext, _world: &World, resources: &Resources) {
let windows = resources.get::<Windows>().unwrap();
let window = windows.get_primary().unwrap();
@ -44,9 +46,3 @@ impl FrameTextureResourceProvider {
}
}
}
impl ResourceProvider for FrameTextureResourceProvider {
fn update(&mut self, render_context: &mut dyn RenderContext, _world: &mut World, resources: &Resources) {
self.update(render_context, resources)
}
}

59
bevy_render/src/render_resource/resource_providers/light_resource_provider.rs
View File

@ -3,7 +3,8 @@ use crate::{
resource_name, BufferInfo, BufferUsage, RenderResource, RenderResourceAssignments,
ResourceProvider,
},
Light, LightRaw, renderer_2::RenderContext,
renderer_2::RenderContext,
Light, LightRaw,
};
use bevy_transform::prelude::{LocalToWorld, Translation};
use legion::prelude::*;
@ -33,7 +34,35 @@ impl LightResourceProvider {
tmp_count_buffer: None,
}
}
fn update_read_only(&mut self, render_context: &mut dyn RenderContext, world: &World) {
}
impl ResourceProvider for LightResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let light_uniform_size =
std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>();
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: light_uniform_size,
buffer_usage: BufferUsage::UNIFORM | BufferUsage::COPY_SRC | BufferUsage::COPY_DST,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::LIGHTS, buffer);
self.light_buffer = Some(buffer);
}
fn update(
&mut self,
render_context: &mut dyn RenderContext,
world: &World,
_resources: &Resources,
) {
if self.lights_are_dirty {
let light_query = <(Read<Light>, Read<LocalToWorld>, Read<Translation>)>::query();
let light_count = light_query.iter(world).count();
@ -101,29 +130,3 @@ impl LightResourceProvider {
}
}
}
impl ResourceProvider for LightResourceProvider {
fn initialize(
&mut self,
render_context: &mut dyn RenderContext,
_world: &mut World,
resources: &Resources,
) {
let light_uniform_size =
std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>();
let buffer = render_context.resources_mut().create_buffer(BufferInfo {
size: light_uniform_size,
buffer_usage: BufferUsage::UNIFORM | BufferUsage::COPY_SRC | BufferUsage::COPY_DST,
..Default::default()
});
let mut render_resource_assignments =
resources.get_mut::<RenderResourceAssignments>().unwrap();
render_resource_assignments.set(resource_name::uniform::LIGHTS, buffer);
self.light_buffer = Some(buffer);
}
fn update(&mut self, render_context: &mut dyn RenderContext, world: &mut World, _resources: &Resources) {
self.update_read_only(render_context, world);
}
}

2
bevy_render/src/render_resource/resource_providers/mesh_resource_provider.rs
View File

@ -91,7 +91,7 @@ impl ResourceProvider for MeshResourceProvider {
vertex_buffer_descriptors.set(Vertex::get_vertex_buffer_descriptor().cloned().unwrap());
}
fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &mut World, _resources: &Resources) {
fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &World, _resources: &Resources) {
}
fn finish_update(

18
bevy_render/src/render_resource/resource_providers/uniform_resource_provider.rs
View File

@ -128,18 +128,6 @@ where
}
}
fn update_readonly(
&mut self,
_render_context: &mut dyn RenderContext,
world: &World,
resources: &Resources,
) {
self.reset_buffer_array_status_counts();
self.update_uniforms_info(world);
self.update_uniform_handles_info(world, resources);
}
fn reset_buffer_array_status_counts(&mut self) {
for buffer_status in self.uniform_buffer_status.iter_mut() {
if let Some((_name, buffer_status)) = buffer_status {
@ -734,10 +722,12 @@ where
fn update(
&mut self,
_render_context: &mut dyn RenderContext,
world: &mut World,
world: &World,
resources: &Resources,
) {
self.update_readonly(_render_context, world, resources);
self.reset_buffer_array_status_counts();
self.update_uniforms_info(world);
self.update_uniform_handles_info(world, resources);
}
fn finish_update(