diff --git a/examples/texture.rs b/examples/texture.rs index e6323bf4b4..29f2765e8d 100644 --- a/examples/texture.rs +++ b/examples/texture.rs @@ -12,7 +12,9 @@ fn setup(world: &mut World) { let texture_handle = { let mut texture_storage = world.resources.get_mut::>().unwrap(); - let texture = Texture::load(TextureType::Png(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/temp_bevy_logo.png").to_string())); + let texture = Texture::load(TextureType::Png( + concat!(env!("CARGO_MANIFEST_DIR"), "/assets/temp_bevy_logo.png").to_string(), + )); texture_storage.add(texture) }; diff --git a/src/app/app_builder.rs b/src/app/app_builder.rs index b473921e42..7928aa4a78 100644 --- a/src/app/app_builder.rs +++ b/src/app/app_builder.rs @@ -7,8 +7,8 @@ use crate::{ render::{ render_graph::{ draw_targets::*, passes::*, pipelines::*, renderers::wgpu_renderer::WgpuRenderer, - resource_name, resource_providers::*, CompiledShaderMap, PipelineDescriptor, - RenderGraphBuilder, Renderer, ShaderPipelineAssignments, StandardMaterial, + resource_providers::*, CompiledShaderMap, PipelineDescriptor, RenderGraphBuilder, + Renderer, ShaderPipelineAssignments, StandardMaterial, }, *, }, @@ -140,12 +140,9 @@ impl AppBuilder { pub fn add_render_graph_defaults(self) -> Self { self.setup_render_graph(|builder, pipeline_storage, shader_storage| { builder - .add_draw_target(resource_name::draw_target::MESHES, meshes_draw_target) - .add_draw_target( - resource_name::draw_target::ASSIGNED_MESHES, - assigned_meshes_draw_target, - ) - .add_draw_target(resource_name::draw_target::UI, ui_draw_target) + .add_draw_target(MeshesDrawTarget::default()) + .add_draw_target(AssignedMeshesDrawTarget::default()) + .add_draw_target(UiDrawTarget::default()) .add_resource_provider(Box::new(CameraResourceProvider::default())) .add_resource_provider(Box::new(Camera2dResourceProvider::default())) .add_resource_provider(Box::new(LightResourceProvider::new(10))) diff --git a/src/asset/texture.rs b/src/asset/texture.rs index e7c22d4f5e..9c20c289a5 100644 --- a/src/asset/texture.rs +++ b/src/asset/texture.rs @@ -1,9 +1,12 @@ -use crate::{render::render_graph::{TextureDimension, TextureDescriptor}, asset::Asset}; +use crate::{ + asset::Asset, + render::render_graph::{TextureDescriptor, TextureDimension}, +}; use std::fs::File; pub enum TextureType { Data(Vec, usize, usize), - Png(String) // TODO: please rethink this + Png(String), // TODO: please rethink this } pub struct Texture { @@ -25,13 +28,17 @@ impl Asset for Texture { } }; - Texture { data, width, height } + Texture { + data, + width, + height, + } } } impl From<&Texture> for TextureDescriptor { fn from(texture: &Texture) -> Self { - TextureDescriptor { + TextureDescriptor { size: wgpu::Extent3d { height: texture.height as u32, width: texture.width as u32, @@ -43,9 +50,8 @@ impl From<&Texture> for TextureDescriptor { dimension: TextureDimension::D2, format: wgpu::TextureFormat::Rgba8UnormSrgb, usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST, - } + } } - } pub fn create_texels(size: usize) -> Vec { diff --git a/src/render/render_graph/draw_target.rs b/src/render/render_graph/draw_target.rs index 52273e8e61..1525740f85 100644 --- a/src/render/render_graph/draw_target.rs +++ b/src/render/render_graph/draw_target.rs @@ -1,3 +1,4 @@ +use super::Renderer; use crate::{ asset::Handle, render::render_graph::{pipeline::PipelineDescriptor, RenderPass}, @@ -12,3 +13,19 @@ pub type DrawTarget = fn( render_pass: &mut dyn RenderPass, pipeline_handle: Handle, ); + +pub trait NewDrawTarget { + fn draw( + &self, + world: &World, + render_pass: &mut dyn RenderPass, + pipeline_handle: Handle, + ); + fn setup( + &mut self, + world: &World, + renderer: &mut dyn Renderer, + pipeline_handle: Handle, + ); + fn get_name(&self) -> String; +} diff --git a/src/render/render_graph/draw_targets/assigned_meshes_draw_target.rs b/src/render/render_graph/draw_targets/assigned_meshes_draw_target.rs index 1a315aedb9..16cd927526 100644 --- a/src/render/render_graph/draw_targets/assigned_meshes_draw_target.rs +++ b/src/render/render_graph/draw_targets/assigned_meshes_draw_target.rs @@ -1,53 +1,98 @@ use crate::{ - asset::{Handle, Mesh}, + asset::{AssetStorage, Handle, Mesh}, legion::prelude::*, - render::render_graph::{PipelineDescriptor, RenderPass, Renderable, ShaderPipelineAssignments, ResourceInfo}, + render::render_graph::{ + resource_name, NewDrawTarget, PipelineDescriptor, RenderPass, Renderable, ResourceInfo, + ShaderPipelineAssignments, + }, }; -pub fn assigned_meshes_draw_target( - world: &World, - render_pass: &mut dyn RenderPass, - pipeline_handle: Handle, -) { - let shader_pipeline_assignments = world - .resources - .get_mut::() - .unwrap(); - let mut current_mesh_handle = None; - let mut current_mesh_index_len = 0; +#[derive(Default)] +pub struct AssignedMeshesDrawTarget; - let assigned_entities = shader_pipeline_assignments - .assignments - .get(&pipeline_handle); +impl NewDrawTarget for AssignedMeshesDrawTarget { + fn draw( + &self, + world: &World, + render_pass: &mut dyn RenderPass, + pipeline_handle: Handle, + ) { + let shader_pipeline_assignments = + world.resources.get::().unwrap(); + let mut current_mesh_handle = None; + let mut current_mesh_index_len = 0; - if let Some(assigned_entities) = assigned_entities { - for entity in assigned_entities.iter() { - // TODO: hopefully legion has better random access apis that are more like queries? - let renderable = world.get_component::(*entity).unwrap(); - let mesh = *world.get_component::>(*entity).unwrap(); - if !renderable.is_visible { - continue; - } + let assigned_entities = shader_pipeline_assignments + .assignments + .get(&pipeline_handle); - let renderer = render_pass.get_renderer(); - let render_resources = renderer.get_render_resources(); - if current_mesh_handle != Some(mesh) { - if let Some(vertex_buffer_resource) = render_resources.get_mesh_vertices_resource(mesh) { - let index_buffer_resource = render_resources.get_mesh_indices_resource(mesh).unwrap(); - match renderer.get_resource_info(index_buffer_resource).unwrap() { - ResourceInfo::Buffer { size, ..} => current_mesh_index_len = (size / 2) as u32, - _ => panic!("expected a buffer type"), - } - render_pass.set_index_buffer(index_buffer_resource, 0); - render_pass.set_vertex_buffer(0, vertex_buffer_resource, 0); + if let Some(assigned_entities) = assigned_entities { + for entity in assigned_entities.iter() { + // TODO: hopefully legion has better random access apis that are more like queries? + let renderable = world.get_component::(*entity).unwrap(); + let mesh = *world.get_component::>(*entity).unwrap(); + if !renderable.is_visible { + continue; } - // TODO: Verify buffer format matches render pass - current_mesh_handle = Some(mesh); - } - // TODO: validate bind group properties against shader uniform properties at least once - render_pass.setup_bind_groups(Some(&entity)); - render_pass.draw_indexed(0..current_mesh_index_len, 0, 0..1); + let renderer = render_pass.get_renderer(); + let render_resources = renderer.get_render_resources(); + if current_mesh_handle != Some(mesh) { + if let Some(vertex_buffer_resource) = + render_resources.get_mesh_vertices_resource(mesh) + { + let index_buffer_resource = + render_resources.get_mesh_indices_resource(mesh).unwrap(); + match renderer.get_resource_info(index_buffer_resource).unwrap() { + ResourceInfo::Buffer { size, .. } => { + current_mesh_index_len = (size / 2) as u32 + } + _ => panic!("expected a buffer type"), + } + render_pass.set_index_buffer(index_buffer_resource, 0); + render_pass.set_vertex_buffer(0, vertex_buffer_resource, 0); + } + // TODO: Verify buffer format matches render pass + current_mesh_handle = Some(mesh); + } + + // TODO: validate bind group properties against shader uniform properties at least once + render_pass.set_bind_groups(Some(&entity)); + render_pass.draw_indexed(0..current_mesh_index_len, 0, 0..1); + } } } + + fn setup( + &mut self, + world: &World, + renderer: &mut dyn crate::render::render_graph::Renderer, + pipeline_handle: Handle, + ) { + let shader_pipeline_assignments = + world.resources.get::().unwrap(); + let assigned_entities = shader_pipeline_assignments + .assignments + .get(&pipeline_handle); + let pipeline_storage = world + .resources + .get::>() + .unwrap(); + let pipeline_descriptor = pipeline_storage.get(&pipeline_handle).unwrap(); + if let Some(assigned_entities) = assigned_entities { + for entity in assigned_entities.iter() { + // TODO: hopefully legion has better random access apis that are more like queries? + let renderable = world.get_component::(*entity).unwrap(); + if !renderable.is_visible { + continue; + } + + renderer.setup_entity_bind_groups(*entity, pipeline_descriptor); + } + } + } + + fn get_name(&self) -> String { + resource_name::draw_target::ASSIGNED_MESHES.to_string() + } } diff --git a/src/render/render_graph/draw_targets/meshes_draw_target.rs b/src/render/render_graph/draw_targets/meshes_draw_target.rs index 96ae961486..0e081324ea 100644 --- a/src/render/render_graph/draw_targets/meshes_draw_target.rs +++ b/src/render/render_graph/draw_targets/meshes_draw_target.rs @@ -2,46 +2,69 @@ use crate::{ asset::{Handle, Mesh}, legion::prelude::*, render::{ - render_graph::{PipelineDescriptor, RenderPass, Renderable, ResourceInfo}, + render_graph::{ + resource_name, NewDrawTarget, PipelineDescriptor, RenderPass, Renderable, ResourceInfo, + }, Instanced, }, }; -pub fn meshes_draw_target( - world: &World, - render_pass: &mut dyn RenderPass, - _pipeline_handle: Handle, -) { - let mut current_mesh_handle = None; - let mut current_mesh_index_len = 0; - let mesh_query = - <(Read>, Read)>::query().filter(!component::()); +#[derive(Default)] +pub struct MeshesDrawTarget; - for (entity, (mesh, renderable)) in mesh_query.iter_entities(world) { - if !renderable.is_visible { - continue; - } +impl NewDrawTarget for MeshesDrawTarget { + fn draw( + &self, + world: &World, + render_pass: &mut dyn RenderPass, + _pipeline_handle: Handle, + ) { + let mut current_mesh_handle = None; + let mut current_mesh_index_len = 0; + let mesh_query = + <(Read>, Read)>::query().filter(!component::()); - let renderer = render_pass.get_renderer(); - let render_resources = renderer.get_render_resources(); - if current_mesh_handle != Some(*mesh) { - if let Some(vertex_buffer_resource) = render_resources.get_mesh_vertices_resource(*mesh) - { - let index_buffer_resource = - render_resources.get_mesh_indices_resource(*mesh).unwrap(); - match renderer.get_resource_info(index_buffer_resource).unwrap() { - ResourceInfo::Buffer { size, .. } => current_mesh_index_len = (size / 2) as u32, - _ => panic!("expected a buffer type"), - } - render_pass.set_index_buffer(index_buffer_resource, 0); - render_pass.set_vertex_buffer(0, vertex_buffer_resource, 0); + for (entity, (mesh, renderable)) in mesh_query.iter_entities(world) { + if !renderable.is_visible { + continue; } - // TODO: Verify buffer format matches render pass - current_mesh_handle = Some(*mesh); - } - // TODO: validate bind group properties against shader uniform properties at least once - render_pass.setup_bind_groups(Some(&entity)); - render_pass.draw_indexed(0..current_mesh_index_len, 0, 0..1); + let renderer = render_pass.get_renderer(); + let render_resources = renderer.get_render_resources(); + if current_mesh_handle != Some(*mesh) { + if let Some(vertex_buffer_resource) = + render_resources.get_mesh_vertices_resource(*mesh) + { + let index_buffer_resource = + render_resources.get_mesh_indices_resource(*mesh).unwrap(); + match renderer.get_resource_info(index_buffer_resource).unwrap() { + ResourceInfo::Buffer { size, .. } => { + current_mesh_index_len = (size / 2) as u32 + } + _ => panic!("expected a buffer type"), + } + render_pass.set_index_buffer(index_buffer_resource, 0); + render_pass.set_vertex_buffer(0, vertex_buffer_resource, 0); + } + // TODO: Verify buffer format matches render pass + current_mesh_handle = Some(*mesh); + } + + // TODO: validate bind group properties against shader uniform properties at least once + render_pass.set_bind_groups(Some(&entity)); + render_pass.draw_indexed(0..current_mesh_index_len, 0, 0..1); + } + } + + fn setup( + &mut self, + _world: &World, + _renderer: &mut dyn crate::render::render_graph::Renderer, + _pipeline_handle: Handle, + ) { + } + + fn get_name(&self) -> String { + resource_name::draw_target::MESHES.to_string() } } diff --git a/src/render/render_graph/draw_targets/ui_draw_target.rs b/src/render/render_graph/draw_targets/ui_draw_target.rs index ab3f2fe9d3..fe39d31ab6 100644 --- a/src/render/render_graph/draw_targets/ui_draw_target.rs +++ b/src/render/render_graph/draw_targets/ui_draw_target.rs @@ -1,77 +1,95 @@ use crate::{ asset::{AssetStorage, Handle, Mesh}, legion::prelude::*, - render::render_graph::{resource_name, PipelineDescriptor, RenderPass, ResourceInfo}, + render::render_graph::{ + resource_name, NewDrawTarget, PipelineDescriptor, RenderPass, ResourceInfo, + }, }; use zerocopy::AsBytes; -pub fn ui_draw_target( - world: &World, - render_pass: &mut dyn RenderPass, - _pipeline_handle: Handle, -) { - // TODO: re-add support for this - // let mesh_storage = world.resources.get_mut::>().unwrap(); - // let mut current_mesh_vertex_buffer = None; - // let mut current_mesh_index_buffer = None; - // let ui_instances_buffer = { - // let renderer = render_pass.get_renderer(); - // match renderer.get_render_resources().get_named_resource(resource_name::buffer::UI_INSTANCES) { - // Some(buffer) => buffer, - // None => return, - // } - // }; - // // NOTE: this is ugly and borrowing is stupid - // let result = { - // let renderer = render_pass.get_renderer(); - // let result = if let Some(ResourceInfo::InstanceBuffer { count, mesh_id, .. }) = - // renderer.get_resource_info(ui_instances_buffer) - // { - // Some((*count, *mesh_id)) - // } else { - // None - // }; +#[derive(Default)] +pub struct UiDrawTarget; - // if let Some((instance_count, mesh_id)) = result { - // if let Some(mesh_asset) = mesh_storage.get_id(mesh_id) { - // if let Some(buffer) = current_mesh_vertex_buffer { - // renderer.remove_buffer(buffer); - // } +impl NewDrawTarget for UiDrawTarget { + fn draw( + &self, + _world: &World, + _render_pass: &mut dyn RenderPass, + _pipeline_handle: Handle, + ) { + // TODO: re-add support for this + // let mesh_storage = world.resources.get_mut::>().unwrap(); + // let mut current_mesh_vertex_buffer = None; + // let mut current_mesh_index_buffer = None; + // let ui_instances_buffer = { + // let renderer = render_pass.get_renderer(); + // match renderer.get_render_resources().get_named_resource(resource_name::buffer::UI_INSTANCES) { + // Some(buffer) => buffer, + // None => return, + // } + // }; + // // NOTE: this is ugly and borrowing is stupid + // let result = { + // let renderer = render_pass.get_renderer(); + // let result = if let Some(ResourceInfo::InstanceBuffer { count, mesh_id, .. }) = + // renderer.get_resource_info(ui_instances_buffer) + // { + // Some((*count, *mesh_id)) + // } else { + // None + // }; - // if let Some(buffer) = current_mesh_index_buffer { - // renderer.remove_buffer(buffer); - // } - // current_mesh_vertex_buffer = Some(renderer.create_buffer_with_data( - // mesh_asset.vertices.as_bytes(), - // wgpu::BufferUsage::VERTEX, - // )); - // current_mesh_index_buffer = Some(renderer.create_buffer_with_data( - // mesh_asset.indices.as_bytes(), - // wgpu::BufferUsage::INDEX, - // )); - // Some((instance_count, mesh_asset.indices.len())) - // } else { - // None - // } - // } else { - // None - // } - // }; - // if let Some((instance_count, indices_length)) = result { - // render_pass.setup_bind_groups(None); - // render_pass.set_index_buffer(current_mesh_index_buffer.unwrap(), 0); - // render_pass.set_vertex_buffer(0, current_mesh_vertex_buffer.unwrap(), 0); - // render_pass.set_vertex_buffer(1, ui_instances_buffer, 0); - // render_pass.draw_indexed(0..indices_length as u32, 0, 0..(instance_count as u32)); - // } + // if let Some((instance_count, mesh_id)) = result { + // if let Some(mesh_asset) = mesh_storage.get_id(mesh_id) { + // if let Some(buffer) = current_mesh_vertex_buffer { + // renderer.remove_buffer(buffer); + // } - // let renderer = render_pass.get_renderer(); - // if let Some(buffer) = current_mesh_vertex_buffer { - // renderer.remove_buffer(buffer); - // } + // if let Some(buffer) = current_mesh_index_buffer { + // renderer.remove_buffer(buffer); + // } + // current_mesh_vertex_buffer = Some(renderer.create_buffer_with_data( + // mesh_asset.vertices.as_bytes(), + // wgpu::BufferUsage::VERTEX, + // )); + // current_mesh_index_buffer = Some(renderer.create_buffer_with_data( + // mesh_asset.indices.as_bytes(), + // wgpu::BufferUsage::INDEX, + // )); + // Some((instance_count, mesh_asset.indices.len())) + // } else { + // None + // } + // } else { + // None + // } + // }; + // if let Some((instance_count, indices_length)) = result { + // render_pass.setup_bind_groups(None); + // render_pass.set_index_buffer(current_mesh_index_buffer.unwrap(), 0); + // render_pass.set_vertex_buffer(0, current_mesh_vertex_buffer.unwrap(), 0); + // render_pass.set_vertex_buffer(1, ui_instances_buffer, 0); + // render_pass.draw_indexed(0..indices_length as u32, 0, 0..(instance_count as u32)); + // } - // if let Some(buffer) = current_mesh_index_buffer { - // renderer.remove_buffer(buffer); - // } + // let renderer = render_pass.get_renderer(); + // if let Some(buffer) = current_mesh_vertex_buffer { + // renderer.remove_buffer(buffer); + // } + + // if let Some(buffer) = current_mesh_index_buffer { + // renderer.remove_buffer(buffer); + // } + } + fn setup( + &mut self, + _world: &World, + _renderer: &mut dyn crate::render::render_graph::Renderer, + _pipeline_handle: Handle, + ) { + } + fn get_name(&self) -> String { + resource_name::draw_target::UI.to_string() + } } diff --git a/src/render/render_graph/pipeline_layout.rs b/src/render/render_graph/pipeline_layout.rs index 36a3c95573..c075269520 100644 --- a/src/render/render_graph/pipeline_layout.rs +++ b/src/render/render_graph/pipeline_layout.rs @@ -99,8 +99,7 @@ impl Hash for BindGroup { impl PartialEq for BindGroup { fn eq(&self, other: &BindGroup) -> bool { - self.index == other.index && - self.bindings == other.bindings + self.index == other.index && self.bindings == other.bindings } } @@ -292,6 +291,6 @@ impl From<&Texture> for SamplerDescriptor { lod_min_clamp: -100.0, lod_max_clamp: 100.0, compare_function: wgpu::CompareFunction::Always, - } + } } -} \ No newline at end of file +} diff --git a/src/render/render_graph/render_graph.rs b/src/render/render_graph/render_graph.rs index 48bec80f92..84cbc8920f 100644 --- a/src/render/render_graph/render_graph.rs +++ b/src/render/render_graph/render_graph.rs @@ -1,9 +1,7 @@ -use crate::{ - asset::{AssetStorage, Handle}, - render::render_graph::{ - DrawTarget, PassDescriptor, PipelineDescriptor, ResourceProvider, TextureDescriptor, - }, +use super::{ + NewDrawTarget, PassDescriptor, PipelineDescriptor, ResourceProvider, TextureDescriptor, }; +use crate::asset::{AssetStorage, Handle}; use std::collections::{HashMap, HashSet}; pub struct RenderGraph { @@ -13,7 +11,7 @@ pub struct RenderGraph { pub pass_pipelines: HashMap>>, pub resource_providers: Vec>, pub queued_textures: Vec<(String, TextureDescriptor)>, - pub draw_targets: HashMap, + pub draw_targets: HashMap>, } impl Default for RenderGraph { @@ -102,10 +100,13 @@ impl RenderGraphBuilder { self } - pub fn add_draw_target(mut self, name: &str, draw_target: DrawTarget) -> Self { + pub fn add_draw_target(mut self, draw_target: T) -> Self + where + T: NewDrawTarget + 'static, + { self.render_graph .draw_targets - .insert(name.to_string(), draw_target); + .insert(draw_target.get_name(), Box::new(draw_target)); self } diff --git a/src/render/render_graph/render_resource.rs b/src/render/render_graph/render_resource.rs index 289898ecac..6a3542cd04 100644 --- a/src/render/render_graph/render_resource.rs +++ b/src/render/render_graph/render_resource.rs @@ -1,4 +1,4 @@ -use crate::asset::{Handle, Texture, Mesh}; +use crate::asset::{Handle, Mesh, Texture}; use std::collections::HashMap; #[derive(Copy, Clone, Hash, Debug, Eq, PartialEq)] @@ -49,7 +49,11 @@ impl RenderResources { self.mesh_to_indices_resource.get(&mesh).cloned() } - pub fn set_texture_sampler_resource(&mut self, texture: Handle, resource: RenderResource) { + pub fn set_texture_sampler_resource( + &mut self, + texture: Handle, + resource: RenderResource, + ) { self.texture_to_sampler_resource.insert(texture, resource); } diff --git a/src/render/render_graph/renderable.rs b/src/render/render_graph/renderable.rs index 95eeef32f5..1d4b1dbbd8 100644 --- a/src/render/render_graph/renderable.rs +++ b/src/render/render_graph/renderable.rs @@ -170,10 +170,8 @@ pub fn update_shader_assignments(world: &mut World, render_graph: &mut RenderGra let macroed_pipeline_handle = pipeline_descriptor_storage.add(macroed_pipeline); // TODO: get correct pass name - render_graph.add_pipeline( - resource_name::pass::MAIN, - macroed_pipeline_handle, - ); + render_graph + .add_pipeline(resource_name::pass::MAIN, macroed_pipeline_handle); macroed_pipeline_handle } else { *pipeline_handle @@ -184,10 +182,7 @@ pub fn update_shader_assignments(world: &mut World, render_graph: &mut RenderGra .pipeline_to_macro_pipelines .get_mut(pipeline_handle) .unwrap(); - macro_pipelines.push(( - renderable.shader_defs.clone(), - macroed_pipeline_handle, - )); + macro_pipelines.push((renderable.shader_defs.clone(), macroed_pipeline_handle)); macroed_pipeline_handle }; diff --git a/src/render/render_graph/renderer.rs b/src/render/render_graph/renderer.rs index 8e129619b7..ca592f2327 100644 --- a/src/render/render_graph/renderer.rs +++ b/src/render/render_graph/renderer.rs @@ -80,8 +80,22 @@ pub trait Renderer { ); fn get_render_resources(&self) -> &RenderResources; fn get_render_resources_mut(&mut self) -> &mut RenderResources; - fn set_entity_uniform_resource(&mut self, entity: Entity, uniform_name: &str, resource: RenderResource); - fn get_entity_uniform_resource(&self, entity: Entity, uniform_name: &str) -> Option; + fn set_entity_uniform_resource( + &mut self, + entity: Entity, + uniform_name: &str, + resource: RenderResource, + ); + fn get_entity_uniform_resource( + &self, + entity: Entity, + uniform_name: &str, + ) -> Option; + fn setup_entity_bind_groups( + &mut self, + entity: Entity, + pipeline_descriptor: &PipelineDescriptor, + ); } pub trait RenderPass { @@ -91,5 +105,5 @@ pub trait RenderPass { fn set_index_buffer(&mut self, resource: RenderResource, offset: u64); fn set_vertex_buffer(&mut self, start_slot: u32, resource: RenderResource, offset: u64); fn draw_indexed(&mut self, indices: Range, base_vertex: i32, instances: Range); - fn setup_bind_groups(&mut self, entity: Option<&Entity>); + fn set_bind_groups(&mut self, entity: Option<&Entity>); } diff --git a/src/render/render_graph/renderers/wgpu_renderer/mod.rs b/src/render/render_graph/renderers/wgpu_renderer/mod.rs index 96f95a2053..141ea54a57 100644 --- a/src/render/render_graph/renderers/wgpu_renderer/mod.rs +++ b/src/render/render_graph/renderers/wgpu_renderer/mod.rs @@ -1,7 +1,7 @@ +mod wgpu_render_pass; mod wgpu_renderer; mod wgpu_resources; -mod wgpu_render_pass; +pub use wgpu_render_pass::*; pub use wgpu_renderer::*; pub use wgpu_resources::*; -pub use wgpu_render_pass::*; \ No newline at end of file diff --git a/src/render/render_graph/renderers/wgpu_renderer/wgpu_render_pass.rs b/src/render/render_graph/renderers/wgpu_renderer/wgpu_render_pass.rs index 5cbd66e6bf..bc4f305ae8 100644 --- a/src/render/render_graph/renderers/wgpu_renderer/wgpu_render_pass.rs +++ b/src/render/render_graph/renderers/wgpu_renderer/wgpu_render_pass.rs @@ -1,5 +1,7 @@ use super::{WgpuRenderer, WgpuResources}; -use crate::render::render_graph::{RenderPass, PipelineDescriptor, Renderer, RenderResource, BindType}; +use crate::render::render_graph::{ + BindType, PipelineDescriptor, RenderPass, RenderResource, Renderer, +}; use legion::prelude::Entity; pub struct WgpuRenderPass<'a, 'b, 'c, 'd> { @@ -39,7 +41,7 @@ impl<'a, 'b, 'c, 'd> RenderPass for WgpuRenderPass<'a, 'b, 'c, 'd> { .draw_indexed(indices, base_vertex, instances); } - fn setup_bind_groups(&mut self, entity: Option<&Entity>) { + fn set_bind_groups(&mut self, entity: Option<&Entity>) { let pipeline_layout = self.pipeline_descriptor.get_layout().unwrap(); for bind_group in pipeline_layout.bind_groups.iter() { let bind_group_id = bind_group.get_hash().unwrap(); @@ -49,14 +51,6 @@ impl<'a, 'b, 'c, 'd> RenderPass for WgpuRenderPass<'a, 'b, 'c, 'd> { // otherwise try to get an entity-specific bind group None => { if let Some(entity) = entity { - if let None = self - .wgpu_resources - .get_entity_bind_group(*entity, bind_group_id) - { - // TODO: Uncomment this - // self.wgpu_resources.create_entity_bind_group(&self.renderer.device, bind_group, *entity); - } - self.wgpu_resources .get_entity_bind_group(*entity, bind_group_id) .unwrap() @@ -103,4 +97,4 @@ impl<'a, 'b, 'c, 'd> RenderPass for WgpuRenderPass<'a, 'b, 'c, 'd> { ); } } -} \ No newline at end of file +} diff --git a/src/render/render_graph/renderers/wgpu_renderer/wgpu_renderer.rs b/src/render/render_graph/renderers/wgpu_renderer/wgpu_renderer.rs index d35af911f8..1f113885f0 100644 --- a/src/render/render_graph/renderers/wgpu_renderer/wgpu_renderer.rs +++ b/src/render/render_graph/renderers/wgpu_renderer/wgpu_renderer.rs @@ -1,21 +1,19 @@ +use super::WgpuRenderPass; use crate::{ asset::{AssetStorage, Handle}, legion::prelude::*, render::{ render_graph::{ - resource_name, update_shader_assignments, BindType, - DynamicUniformBufferInfo, PassDescriptor, PipelineDescriptor, PipelineLayout, + renderers::wgpu_renderer::WgpuResources, resource_name, update_shader_assignments, + BindType, DynamicUniformBufferInfo, PassDescriptor, PipelineDescriptor, PipelineLayout, PipelineLayoutType, RenderGraph, RenderPassColorAttachmentDescriptor, RenderPassDepthStencilAttachmentDescriptor, RenderResource, RenderResources, Renderer, ResourceInfo, SamplerDescriptor, TextureDescriptor, - renderers::wgpu_renderer::WgpuResources, }, Shader, }, }; use std::{collections::HashMap, ops::Deref}; -use super::WgpuRenderPass; - pub struct WgpuRenderer { pub device: wgpu::Device, @@ -201,10 +199,9 @@ impl WgpuRenderer { .iter() .map(|c| Self::create_wgpu_color_attachment_descriptor(wgpu_resources, c, frame)) .collect::>(), - depth_stencil_attachment: pass_descriptor - .depth_stencil_attachment - .as_ref() - .map(|d| Self::create_wgpu_depth_stencil_attachment_descriptor(wgpu_resources, d, frame)), + depth_stencil_attachment: pass_descriptor.depth_stencil_attachment.as_ref().map(|d| { + Self::create_wgpu_depth_stencil_attachment_descriptor(wgpu_resources, d, frame) + }), }) } @@ -232,7 +229,10 @@ impl WgpuRenderer { let resolve_target = match color_attachment_descriptor.resolve_target { Some(ref target) => match target.as_str() { resource_name::texture::SWAP_CHAIN => Some(&frame.view), - _ => match wgpu_resources.render_resources.get_named_resource(target.as_str()) { + _ => match wgpu_resources + .render_resources + .get_named_resource(target.as_str()) + { Some(resource) => Some(wgpu_resources.textures.get(&resource).unwrap()), None => panic!( "Color attachment {} does not exist", @@ -284,7 +284,6 @@ impl WgpuRenderer { } } - pub fn create_shader_module( device: &wgpu::Device, shader: &Shader, @@ -310,7 +309,6 @@ impl WgpuRenderer { let command_buffer = self.encoder.take().unwrap().finish(); self.queue.submit(&[command_buffer]); } - } impl Renderer for WgpuRenderer { @@ -373,7 +371,9 @@ impl Renderer for WgpuRenderer { for (name, texture_descriptor) in render_graph.queued_textures.drain(..) { let resource = self.create_texture(&texture_descriptor, None); - self.wgpu_resources.render_resources.set_named_resource(&name, resource); + self.wgpu_resources + .render_resources + .set_named_resource(&name, resource); } let mut encoder = self.encoder.take().unwrap(); @@ -425,13 +425,33 @@ impl Renderer for WgpuRenderer { // create bind groups let pipeline_layout = pipeline_descriptor.get_layout().unwrap(); for bind_group in pipeline_layout.bind_groups.iter() { - self.wgpu_resources.setup_bind_group(&self.device, bind_group); + self.wgpu_resources + .setup_bind_group(&self.device, bind_group); } } + // setup draw targets + for (pass_name, _pass_descriptor) in render_graph.pass_descriptors.iter() { + if let Some(pass_pipelines) = render_graph.pass_pipelines.get(pass_name) { + for pass_pipeline in pass_pipelines.iter() { + let pipeline_descriptor = pipeline_storage.get(pass_pipeline).unwrap(); + for draw_target_name in pipeline_descriptor.draw_targets.iter() { + let draw_target = + render_graph.draw_targets.get_mut(draw_target_name).unwrap(); + draw_target.setup(world, self, *pass_pipeline); + } + } + } + } + + // begin render passes for (pass_name, pass_descriptor) in render_graph.pass_descriptors.iter() { - // run passes - let mut render_pass = Self::create_render_pass(&self.wgpu_resources, pass_descriptor, &mut encoder, &frame); + let mut render_pass = Self::create_render_pass( + &self.wgpu_resources, + pass_descriptor, + &mut encoder, + &frame, + ); if let Some(pass_pipelines) = render_graph.pass_pipelines.get(pass_name) { for pass_pipeline in pass_pipelines.iter() { let pipeline_descriptor = pipeline_storage.get(pass_pipeline).unwrap(); @@ -442,12 +462,12 @@ impl Renderer for WgpuRenderer { render_pass: &mut render_pass, pipeline_descriptor, wgpu_resources: &self.wgpu_resources, - renderer: &self + renderer: &self, }; for draw_target_name in pipeline_descriptor.draw_targets.iter() { let draw_target = render_graph.draw_targets.get(draw_target_name).unwrap(); - draw_target(world, &mut wgpu_render_pass, *pass_pipeline); + draw_target.draw(world, &mut wgpu_render_pass, *pass_pipeline); } } } @@ -462,11 +482,13 @@ impl Renderer for WgpuRenderer { data: &[u8], buffer_usage: wgpu::BufferUsage, ) -> RenderResource { - self.wgpu_resources.create_buffer_with_data(&self.device, data, buffer_usage) + self.wgpu_resources + .create_buffer_with_data(&self.device, data, buffer_usage) } fn create_buffer(&mut self, size: u64, buffer_usage: wgpu::BufferUsage) -> RenderResource { - self.wgpu_resources.create_buffer(&self.device, size, buffer_usage) + self.wgpu_resources + .create_buffer(&self.device, size, buffer_usage) } fn create_instance_buffer( @@ -476,7 +498,8 @@ impl Renderer for WgpuRenderer { count: usize, buffer_usage: wgpu::BufferUsage, ) -> RenderResource { - self.wgpu_resources.create_instance_buffer(&self.device, mesh_id, size, count, buffer_usage) + self.wgpu_resources + .create_instance_buffer(&self.device, mesh_id, size, count, buffer_usage) } fn create_instance_buffer_with_data( @@ -487,7 +510,14 @@ impl Renderer for WgpuRenderer { count: usize, buffer_usage: wgpu::BufferUsage, ) -> RenderResource { - self.wgpu_resources.create_instance_buffer_with_data(&self.device, mesh_id, data, size, count, buffer_usage) + self.wgpu_resources.create_instance_buffer_with_data( + &self.device, + mesh_id, + data, + size, + count, + buffer_usage, + ) } fn get_resource_info(&self, resource: RenderResource) -> Option<&ResourceInfo> { @@ -504,7 +534,8 @@ impl Renderer for WgpuRenderer { buffer_usage: wgpu::BufferUsage, setup_data: &mut dyn FnMut(&mut [u8]), ) -> RenderResource { - self.wgpu_resources.create_buffer_mapped(&self.device, size, buffer_usage, setup_data) + self.wgpu_resources + .create_buffer_mapped(&self.device, size, buffer_usage, setup_data) } fn copy_buffer_to_buffer( @@ -515,21 +546,30 @@ impl Renderer for WgpuRenderer { destination_offset: u64, size: u64, ) { - self.wgpu_resources.copy_buffer_to_buffer(self.encoder.as_mut().unwrap(), source_buffer, source_offset, destination_buffer, destination_offset, size); + self.wgpu_resources.copy_buffer_to_buffer( + self.encoder.as_mut().unwrap(), + source_buffer, + source_offset, + destination_buffer, + destination_offset, + size, + ); } fn get_dynamic_uniform_buffer_info( &self, resource: RenderResource, ) -> Option<&DynamicUniformBufferInfo> { - self.wgpu_resources.get_dynamic_uniform_buffer_info(resource) + self.wgpu_resources + .get_dynamic_uniform_buffer_info(resource) } fn get_dynamic_uniform_buffer_info_mut( &mut self, resource: RenderResource, ) -> Option<&mut DynamicUniformBufferInfo> { - self.wgpu_resources.get_dynamic_uniform_buffer_info_mut(resource) + self.wgpu_resources + .get_dynamic_uniform_buffer_info_mut(resource) } fn add_dynamic_uniform_buffer_info( @@ -537,11 +577,13 @@ impl Renderer for WgpuRenderer { resource: RenderResource, info: DynamicUniformBufferInfo, ) { - self.wgpu_resources.add_dynamic_uniform_buffer_info(resource, info); + self.wgpu_resources + .add_dynamic_uniform_buffer_info(resource, info); } fn create_sampler(&mut self, sampler_descriptor: &SamplerDescriptor) -> RenderResource { - self.wgpu_resources.create_sampler(&self.device, sampler_descriptor) + self.wgpu_resources + .create_sampler(&self.device, sampler_descriptor) } fn create_texture( @@ -549,7 +591,12 @@ impl Renderer for WgpuRenderer { texture_descriptor: &TextureDescriptor, bytes: Option<&[u8]>, ) -> RenderResource { - self.wgpu_resources.create_texture(&self.device, self.encoder.as_mut().unwrap(), texture_descriptor, bytes) + self.wgpu_resources.create_texture( + &self.device, + self.encoder.as_mut().unwrap(), + texture_descriptor, + bytes, + ) } fn remove_texture(&mut self, resource: RenderResource) { @@ -574,14 +621,37 @@ impl Renderer for WgpuRenderer { uniform_name: &str, resource: RenderResource, ) { - self.wgpu_resources.set_entity_uniform_resource(entity, uniform_name, resource) + self.wgpu_resources + .set_entity_uniform_resource(entity, uniform_name, resource) } fn get_entity_uniform_resource( &self, entity: Entity, uniform_name: &str, ) -> Option { - self.wgpu_resources.get_entity_uniform_resource(entity, uniform_name) + self.wgpu_resources + .get_entity_uniform_resource(entity, uniform_name) + } + + fn setup_entity_bind_groups( + &mut self, + entity: Entity, + pipeline_descriptor: &PipelineDescriptor, + ) { + let pipeline_layout = pipeline_descriptor.get_layout().unwrap(); + for bind_group in pipeline_layout.bind_groups.iter() { + let bind_group_id = bind_group.get_hash().unwrap(); + // only setup entity bind groups if there isn't already a "global" bind group created + if let None = self.wgpu_resources.bind_groups.get(&bind_group_id) { + if let None = self + .wgpu_resources + .get_entity_bind_group(entity, bind_group_id) + { + self.wgpu_resources + .create_entity_bind_group(&self.device, bind_group, entity); + } + } + } } } @@ -609,4 +679,4 @@ impl From<&BindType> for wgpu::BindingType { }, } } -} \ No newline at end of file +} diff --git a/src/render/render_graph/renderers/wgpu_renderer/wgpu_resources.rs b/src/render/render_graph/renderers/wgpu_renderer/wgpu_resources.rs index 5d5cc95d32..34e38103ed 100644 --- a/src/render/render_graph/renderers/wgpu_renderer/wgpu_resources.rs +++ b/src/render/render_graph/renderers/wgpu_renderer/wgpu_resources.rs @@ -1,11 +1,8 @@ use crate::{ legion::prelude::*, - render::{ - render_graph::{ - BindGroup, BindType, - DynamicUniformBufferInfo, RenderResource, RenderResources, - ResourceInfo, SamplerDescriptor, TextureDescriptor, - }, + render::render_graph::{ + BindGroup, BindType, DynamicUniformBufferInfo, RenderResource, RenderResources, + ResourceInfo, SamplerDescriptor, TextureDescriptor, }, }; use std::{borrow::Cow, collections::HashMap}; @@ -152,7 +149,12 @@ impl WgpuResources { self.entity_bind_groups.get(&(entity, bind_group_id)) } - pub fn create_entity_bind_group(&mut self, device: &wgpu::Device, bind_group: &BindGroup, entity: Entity) { + pub fn create_entity_bind_group( + &mut self, + device: &wgpu::Device, + bind_group: &BindGroup, + entity: Entity, + ) { // TODO: don't make this per-entity. bind groups should be re-used across the same resource when possible let bind_group_id = bind_group.get_hash().unwrap(); let bindings = bind_group @@ -208,7 +210,12 @@ impl WgpuResources { ); } - pub fn create_buffer(&mut self, device: &wgpu::Device, size: u64, buffer_usage: wgpu::BufferUsage) -> RenderResource { + pub fn create_buffer( + &mut self, + device: &wgpu::Device, + size: u64, + buffer_usage: wgpu::BufferUsage, + ) -> RenderResource { let buffer = device.create_buffer(&wgpu::BufferDescriptor { size, usage: buffer_usage, @@ -364,7 +371,11 @@ impl WgpuResources { self.dynamic_uniform_buffer_info.insert(resource, info); } - pub fn create_sampler(&mut self, device: &wgpu::Device, sampler_descriptor: &SamplerDescriptor) -> RenderResource { + pub fn create_sampler( + &mut self, + device: &wgpu::Device, + sampler_descriptor: &SamplerDescriptor, + ) -> RenderResource { let descriptor: wgpu::SamplerDescriptor = (*sampler_descriptor).into(); let sampler = device.create_sampler(&descriptor); let resource = self.render_resources.get_next_resource(); @@ -384,8 +395,7 @@ impl WgpuResources { let texture = device.create_texture(&descriptor); let texture_view = texture.create_default_view(); if let Some(bytes) = bytes { - let temp_buf = device - .create_buffer_with_data(bytes, wgpu::BufferUsage::COPY_SRC); + let temp_buf = device.create_buffer_with_data(bytes, wgpu::BufferUsage::COPY_SRC); encoder.copy_buffer_to_texture( wgpu::BufferCopyView { buffer: &temp_buf, @@ -447,4 +457,4 @@ impl WgpuResources { .get(&(Cow::Owned(entity), Cow::Borrowed(uniform_name))) .cloned() } -} \ No newline at end of file +} diff --git a/src/render/render_graph/resource_providers/camera2d_resource_provider.rs b/src/render/render_graph/resource_providers/camera2d_resource_provider.rs index 0001cbe4f0..5e0873c160 100644 --- a/src/render/render_graph/resource_providers/camera2d_resource_provider.rs +++ b/src/render/render_graph/resource_providers/camera2d_resource_provider.rs @@ -18,7 +18,9 @@ impl ResourceProvider for Camera2dResourceProvider { wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM, ); - renderer.get_render_resources_mut().set_named_resource(resource_name::uniform::CAMERA2D, buffer); + renderer + .get_render_resources_mut() + .set_named_resource(resource_name::uniform::CAMERA2D, buffer); self.camera_buffer = Some(buffer); } diff --git a/src/render/render_graph/resource_providers/camera_resource_provider.rs b/src/render/render_graph/resource_providers/camera_resource_provider.rs index 67047bac01..535aa5c322 100644 --- a/src/render/render_graph/resource_providers/camera_resource_provider.rs +++ b/src/render/render_graph/resource_providers/camera_resource_provider.rs @@ -19,7 +19,9 @@ impl ResourceProvider for CameraResourceProvider { wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM, ); - renderer.get_render_resources_mut().set_named_resource(resource_name::uniform::CAMERA, buffer); + renderer + .get_render_resources_mut() + .set_named_resource(resource_name::uniform::CAMERA, buffer); self.camera_buffer = Some(buffer); } diff --git a/src/render/render_graph/resource_providers/frame_texture_resource_provider.rs b/src/render/render_graph/resource_providers/frame_texture_resource_provider.rs index 1f0d5c4bf3..df2d2cb93c 100644 --- a/src/render/render_graph/resource_providers/frame_texture_resource_provider.rs +++ b/src/render/render_graph/resource_providers/frame_texture_resource_provider.rs @@ -22,12 +22,17 @@ impl FrameTextureResourceProvider { self.descriptor.size.width = window_size.width; self.descriptor.size.height = window_size.height; - if let Some(old_resource) = renderer.get_render_resources().get_named_resource(&self.name) { + if let Some(old_resource) = renderer + .get_render_resources() + .get_named_resource(&self.name) + { renderer.remove_texture(old_resource); } let texture_resource = renderer.create_texture(&self.descriptor, None); - renderer.get_render_resources_mut().set_named_resource(&self.name, texture_resource); + renderer + .get_render_resources_mut() + .set_named_resource(&self.name, texture_resource); } } diff --git a/src/render/render_graph/resource_providers/light_resource_provider.rs b/src/render/render_graph/resource_providers/light_resource_provider.rs index 3e19feb37f..aeb9b74f01 100644 --- a/src/render/render_graph/resource_providers/light_resource_provider.rs +++ b/src/render/render_graph/resource_providers/light_resource_provider.rs @@ -42,7 +42,9 @@ impl ResourceProvider for LightResourceProvider { light_uniform_size, wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_SRC | wgpu::BufferUsage::COPY_DST, ); - renderer.get_render_resources_mut().set_named_resource(resource_name::uniform::LIGHTS, buffer); + renderer + .get_render_resources_mut() + .set_named_resource(resource_name::uniform::LIGHTS, buffer); self.light_buffer = Some(buffer); } diff --git a/src/render/render_graph/resource_providers/mod.rs b/src/render/render_graph/resource_providers/mod.rs index bb2cba5f58..855535e8da 100644 --- a/src/render/render_graph/resource_providers/mod.rs +++ b/src/render/render_graph/resource_providers/mod.rs @@ -2,14 +2,14 @@ mod camera2d_resource_provider; mod camera_resource_provider; mod frame_texture_resource_provider; mod light_resource_provider; +mod mesh_resource_provider; mod ui_resource_provider; mod uniform_resource_provider; -mod mesh_resource_provider; pub use camera2d_resource_provider::*; pub use camera_resource_provider::*; pub use frame_texture_resource_provider::*; pub use light_resource_provider::*; +pub use mesh_resource_provider::*; pub use ui_resource_provider::*; pub use uniform_resource_provider::*; -pub use mesh_resource_provider::*; diff --git a/src/render/render_graph/resource_providers/ui_resource_provider.rs b/src/render/render_graph/resource_providers/ui_resource_provider.rs index e81f7685ef..8fe1a24e7c 100644 --- a/src/render/render_graph/resource_providers/ui_resource_provider.rs +++ b/src/render/render_graph/resource_providers/ui_resource_provider.rs @@ -82,7 +82,9 @@ impl UiResourceProvider { wgpu::BufferUsage::COPY_SRC | wgpu::BufferUsage::VERTEX, ); - renderer.get_render_resources_mut().set_named_resource(resource_name::buffer::UI_INSTANCES, buffer); + renderer + .get_render_resources_mut() + .set_named_resource(resource_name::buffer::UI_INSTANCES, buffer); self.instance_buffer = Some(buffer); } } diff --git a/src/render/render_graph/resource_providers/uniform_resource_provider.rs b/src/render/render_graph/resource_providers/uniform_resource_provider.rs index 3df4977003..9b151fd34b 100644 --- a/src/render/render_graph/resource_providers/uniform_resource_provider.rs +++ b/src/render/render_graph/resource_providers/uniform_resource_provider.rs @@ -2,11 +2,16 @@ use crate::{ asset::{AssetStorage, Texture}, render::render_graph::{ render_resource::RenderResource, AsUniforms, BindType, DynamicUniformBufferInfo, - Renderable, Renderer, ResourceProvider, TextureDescriptor, UniformInfoIter, SamplerDescriptor, + Renderable, Renderer, ResourceProvider, SamplerDescriptor, TextureDescriptor, + UniformInfoIter, }, }; use legion::prelude::*; -use std::{marker::PhantomData, ops::Deref, collections::{HashSet, HashMap}}; +use std::{ + collections::{HashMap, HashSet}, + marker::PhantomData, + ops::Deref, +}; pub struct UniformResourceProvider where @@ -14,7 +19,8 @@ where { _marker: PhantomData, // PERF: somehow remove this HashSet - uniform_buffer_info_resources: HashMap, usize, HashSet)>, + uniform_buffer_info_resources: + HashMap, usize, HashSet)>, } impl UniformResourceProvider @@ -63,7 +69,10 @@ where .insert(uniform_info.name.to_string(), (None, 0, HashSet::new())); } - let (_resource, counts, entities) = self.uniform_buffer_info_resources.get_mut(uniform_info.name).unwrap(); + let (_resource, counts, entities) = self + .uniform_buffer_info_resources + .get_mut(uniform_info.name) + .unwrap(); entities.insert(entity); *counts += 1; } @@ -72,13 +81,18 @@ where uniforms.get_uniform_texture(&uniform_info.name).unwrap(); let storage = world.resources.get::>().unwrap(); let texture = storage.get(&texture_handle).unwrap(); - let resource = match renderer.get_render_resources().get_texture_resource(texture_handle) { + let resource = match renderer + .get_render_resources() + .get_texture_resource(texture_handle) + { Some(resource) => resource, None => { let descriptor: TextureDescriptor = texture.into(); let resource = renderer.create_texture(&descriptor, Some(&texture.data)); - renderer.get_render_resources_mut().set_texture_resource(texture_handle, resource); + renderer + .get_render_resources_mut() + .set_texture_resource(texture_handle, resource); resource } }; @@ -90,13 +104,17 @@ where uniforms.get_uniform_texture(&uniform_info.name).unwrap(); let storage = world.resources.get::>().unwrap(); let texture = storage.get(&texture_handle).unwrap(); - let resource = match renderer.get_render_resources().get_texture_sampler_resource(texture_handle) { + let resource = match renderer + .get_render_resources() + .get_texture_sampler_resource(texture_handle) + { Some(resource) => resource, None => { let descriptor: SamplerDescriptor = texture.into(); - let resource = - renderer.create_sampler(&descriptor); - renderer.get_render_resources_mut().set_texture_sampler_resource(texture_handle, resource); + let resource = renderer.create_sampler(&descriptor); + renderer + .get_render_resources_mut() + .set_texture_sampler_resource(texture_handle, resource); resource } }; @@ -135,7 +153,9 @@ where info.capacity = capacity; renderer.add_dynamic_uniform_buffer_info(created_resource, info); *resource = Some(created_resource); - renderer.get_render_resources_mut().set_named_resource(name, created_resource); + renderer + .get_render_resources_mut() + .set_named_resource(name, created_resource); } // copy entity uniform data to buffers @@ -153,7 +173,7 @@ where .unwrap(); for (entity, _) in query.iter_entities(world) { if !entities.contains(&entity) { - continue; + continue; } // TODO: check if index has changed. if it has, then entity should be updated // TODO: only mem-map entities if their data has changed @@ -171,7 +191,7 @@ where let mut offset = 0usize; for (entity, (uniforms, _renderable)) in query.iter_entities(world) { if !entities.contains(&entity) { - continue; + continue; } // TODO: check if index has changed. if it has, then entity should be updated // TODO: only mem-map entities if their data has changed diff --git a/src/render/render_graph/uniforms/local_to_world.rs b/src/render/render_graph/uniforms/local_to_world.rs index c062454bc4..c58b21fca7 100644 --- a/src/render/render_graph/uniforms/local_to_world.rs +++ b/src/render/render_graph/uniforms/local_to_world.rs @@ -1,4 +1,7 @@ -use crate::{asset::{Handle, Texture}, render::render_graph::{uniform::AsUniforms, FieldBindType, FieldUniformName}}; +use crate::{ + asset::{Handle, Texture}, + render::render_graph::{uniform::AsUniforms, FieldBindType, FieldUniformName}, +}; use zerocopy::AsBytes; diff --git a/src/render/shader_reflect.rs b/src/render/shader_reflect.rs index e4b8d19962..b4aaf1c630 100644 --- a/src/render/shader_reflect.rs +++ b/src/render/shader_reflect.rs @@ -71,14 +71,20 @@ fn reflect_dimension(type_description: &ReflectTypeDescription) -> TextureViewDi fn reflect_binding(binding: &ReflectDescriptorBinding) -> Binding { let type_description = binding.type_description.as_ref().unwrap(); let (name, bind_type) = match binding.descriptor_type { - ReflectDescriptorType::UniformBuffer => (&type_description.type_name, BindType::Uniform { - dynamic: false, - properties: vec![reflect_uniform(type_description)], - }), - ReflectDescriptorType::SampledImage => (&binding.name, BindType::SampledTexture { - dimension: reflect_dimension(type_description), - multisampled: false, - }), + ReflectDescriptorType::UniformBuffer => ( + &type_description.type_name, + BindType::Uniform { + dynamic: false, + properties: vec![reflect_uniform(type_description)], + }, + ), + ReflectDescriptorType::SampledImage => ( + &binding.name, + BindType::SampledTexture { + dimension: reflect_dimension(type_description), + multisampled: false, + }, + ), ReflectDescriptorType::Sampler => (&binding.name, BindType::Sampler), _ => panic!("unsupported bind type {:?}", binding.descriptor_type), };