cargo fmt

examples/setup_system.rs

@@ -19,7 +19,7 @@ pub fn setup() -> Box<dyn Schedulable> {
                 albedo: Color::rgb(0.1, 0.2, 0.1),
                 ..Default::default()
             });
-            
+
             command_buffer
                 .build()
                 // plane
@@ -61,4 +61,4 @@ pub fn setup() -> Box<dyn Schedulable> {
                 })
                 .build();
         })
-}
+}

src/ecs/world_builder.rs

@@ -162,7 +162,10 @@ impl<'a> CommandBufferBuilder<'a> {
         self
     }
 
-    pub fn add_children(mut self, build_children: impl Fn(CommandBufferBuilder) -> CommandBufferBuilder) -> Self {
+    pub fn add_children(
+        mut self,
+        build_children: impl Fn(CommandBufferBuilder) -> CommandBufferBuilder,
+    ) -> Self {
         self.parent_entity = self.current_entity;
         self.current_entity = None;
 

src/lib.rs

@@ -13,4 +13,4 @@ pub mod ui;
 pub use bevy_transform as transform;
 pub use glam as math;
 pub use legion;
-pub use once_cell;
+pub use once_cell;

src/prelude.rs

@@ -3,7 +3,10 @@ pub use crate::{
     asset::{Asset, AssetStorage, Handle},
     core::Time,
     ecs,
-    ecs::{default_archetypes::*, EntityArchetype, WorldBuilder, WorldBuilderSource, CommandBufferBuilderSource},
+    ecs::{
+        default_archetypes::*, CommandBufferBuilderSource, EntityArchetype, WorldBuilder,
+        WorldBuilderSource,
+    },
     render::{
         mesh::{Mesh, MeshType},
         pipeline::PipelineDescriptor,
@@ -14,6 +17,7 @@ pub use crate::{
     },
     ui::{Anchors, Margins, Node},
 };
+pub use bevy_derive::*;
 pub use bevy_transform::prelude::*;
 pub use glam as math;
 pub use legion::{
@@ -24,4 +28,3 @@ pub use legion::{
     },
 };
 pub use math::{Mat3, Mat4, Quat, Vec2, Vec3, Vec4};
-pub use bevy_derive::*;

src/render/light.rs

@@ -1,4 +1,4 @@
-use super::{PerspectiveCamera, Color};
+use super::{Color, PerspectiveCamera};
 use crate::{math, prelude::Translation};
 use std::ops::Range;
 use zerocopy::{AsBytes, FromBytes};

src/render/pipeline/pipeline.rs

@@ -122,10 +122,7 @@ pub struct PipelineBuilder<'a> {
 }
 
 impl<'a> PipelineBuilder<'a> {
-    pub fn new(
+    pub fn new(name: &'a str, shader_storage: &'a mut AssetStorage<Shader>) -> Self {
-        name: &'a str,
-        shader_storage: &'a mut AssetStorage<Shader>,
-    ) -> Self {
         PipelineBuilder {
             pipeline: None,
             shader_storage,
@@ -139,7 +136,10 @@ impl<'a> PipelineBuilder<'a> {
 
     pub fn with_vertex_shader(&mut self, vertex_shader: Shader) -> &mut Self {
         let vertex_shader_handle = self.shader_storage.add(vertex_shader);
-        self.pipeline = Some(PipelineDescriptor::new(Some(&self.name), vertex_shader_handle));
+        self.pipeline = Some(PipelineDescriptor::new(
+            Some(&self.name),
+            vertex_shader_handle,
+        ));
         self
     }
 
@@ -150,7 +150,11 @@ impl<'a> PipelineBuilder<'a> {
     }
 
     pub fn add_color_state(&mut self, color_state_descriptor: ColorStateDescriptor) -> &mut Self {
-        self.pipeline.as_mut().unwrap().color_states.push(color_state_descriptor);
+        self.pipeline
+            .as_mut()
+            .unwrap()
+            .color_states
+            .push(color_state_descriptor);
         self
     }
 
@@ -167,7 +171,8 @@ impl<'a> PipelineBuilder<'a> {
 
     pub fn add_bind_group(&mut self, bind_group: BindGroup) -> &mut Self {
         if let PipelineLayoutType::Reflected(_) = self.pipeline.as_ref().unwrap().layout {
-            self.pipeline.as_mut().unwrap().layout = PipelineLayoutType::Manual(PipelineLayout::new());
+            self.pipeline.as_mut().unwrap().layout =
+                PipelineLayoutType::Manual(PipelineLayout::new());
         }
 
         if let PipelineLayoutType::Manual(ref mut layout) = self.pipeline.as_mut().unwrap().layout {
@@ -181,8 +186,9 @@ impl<'a> PipelineBuilder<'a> {
         &mut self,
         vertex_buffer_descriptor: VertexBufferDescriptor,
     ) -> &mut Self {
-        self.pipeline.as_mut().unwrap().reflect_vertex_buffer_descriptors = false;
+        let pipeline = self.pipeline.as_mut().unwrap();
-        self.pipeline.as_mut().unwrap()
+        pipeline.reflect_vertex_buffer_descriptors = false;
+        pipeline
             .vertex_buffer_descriptors
             .push(vertex_buffer_descriptor);
         self
@@ -194,7 +200,11 @@ impl<'a> PipelineBuilder<'a> {
     }
 
     pub fn add_draw_target(&mut self, name: &str) -> &mut Self {
-        self.pipeline.as_mut().unwrap().draw_targets.push(name.to_string());
+        self.pipeline
+            .as_mut()
+            .unwrap()
+            .draw_targets
+            .push(name.to_string());
         self
     }
 

src/render/pipeline/pipelines/forward_flat/mod.rs

@@ -1,17 +1,13 @@
-use crate::{
+use crate::render::{
-    render::{
+    pipeline::state_descriptors::{
-        pipeline::{
+        BlendDescriptor, ColorStateDescriptor, ColorWrite, CompareFunction, CullMode,
-            state_descriptors::{
+        DepthStencilStateDescriptor, FrontFace, RasterizationStateDescriptor,
-                BlendDescriptor, ColorStateDescriptor, ColorWrite, CompareFunction, CullMode,
+        StencilStateFaceDescriptor,
-                DepthStencilStateDescriptor, FrontFace, RasterizationStateDescriptor,
-                StencilStateFaceDescriptor,
-            },
-        },
-        render_graph::RenderGraphBuilder,
-        render_resource::resource_name,
-        shader::{Shader, ShaderStage},
-        texture::TextureFormat,
     },
+    render_graph::RenderGraphBuilder,
+    render_resource::resource_name,
+    shader::{Shader, ShaderStage},
+    texture::TextureFormat,
 };
 
 pub trait ForwardFlatPipelineBuilder {

src/render/render_graph/render_graph.rs

@@ -1,3 +1,4 @@
+use super::RenderGraphBuilder;
 use crate::{
     asset::Handle,
     prelude::Resources,
@@ -10,7 +11,6 @@ use crate::{
     },
 };
 use std::collections::{HashMap, HashSet};
-use super::RenderGraphBuilder;
 
 #[derive(Default)]
 pub struct RenderGraph {

src/render/render_graph/render_graph_builder.rs

@@ -1,10 +1,14 @@
 use super::RenderGraph;
 use crate::{
     asset::AssetStorage,
+    prelude::{Resources, Shader},
     render::{
-        draw_target::DrawTarget, pass::PassDescriptor, pipeline::{PipelineBuilder, PipelineDescriptor},
+        draw_target::DrawTarget,
-        render_resource::ResourceProvider, texture::TextureDescriptor,
+        pass::PassDescriptor,
-    }, prelude::{Shader, Resources},
+        pipeline::{PipelineBuilder, PipelineDescriptor},
+        render_resource::ResourceProvider,
+        texture::TextureDescriptor,
+    },
 };
 
 pub struct RenderGraphBuilder<'a> {
@@ -16,27 +20,29 @@ pub struct RenderGraphBuilder<'a> {
 impl<'a> RenderGraphBuilder<'a> {
     pub fn add_pass(&mut self, name: &str, pass: PassDescriptor) -> &mut Self {
         self.current_pass = Some(name.to_string());
-        self.render_graph.as_mut().unwrap()
+        self.render_graph
+            .as_mut()
+            .unwrap()
             .pass_descriptors
             .insert(name.to_string(), pass);
         self
     }
 
-    pub fn add_pipeline(
+    pub fn add_pipeline(&mut self, name: &str, build: impl Fn(&mut PipelineBuilder)) -> &mut Self {
-        &mut self,
+        let mut pipeline_descriptor_storage = self
-        name: &str,
+            .resources
-        build: impl Fn(&mut PipelineBuilder),
+            .get_mut::<AssetStorage<PipelineDescriptor>>()
-    ) -> &mut Self {
+            .unwrap();
-        let mut pipeline_descriptor_storage = self.resources.get_mut::<AssetStorage<PipelineDescriptor>>().unwrap();
         let mut shader_storage = self.resources.get_mut::<AssetStorage<Shader>>().unwrap();
         if let Some(ref pass) = self.current_pass {
             let mut builder = PipelineBuilder::new(name, &mut shader_storage);
             build(&mut builder);
             let pipeline = builder.finish();
             let pipeline_descriptor_handle = pipeline_descriptor_storage.add(pipeline);
-            pipeline_descriptor_storage
+            pipeline_descriptor_storage.set_name(name, pipeline_descriptor_handle);
-                .set_name(name, pipeline_descriptor_handle);
+            self.render_graph
-            self.render_graph.as_mut().unwrap()
+                .as_mut()
+                .unwrap()
                 .add_pipeline(&pass, pipeline_descriptor_handle);
         }
 
@@ -49,14 +55,19 @@ impl<'a> RenderGraphBuilder<'a> {
         name: &str,
         build: impl Fn(&mut PipelineBuilder),
     ) -> &mut Self {
-        let mut pipeline_descriptor_storage = self.resources.get_mut::<AssetStorage<PipelineDescriptor>>().unwrap();
+        let mut pipeline_descriptor_storage = self
+            .resources
+            .get_mut::<AssetStorage<PipelineDescriptor>>()
+            .unwrap();
         let mut shader_storage = self.resources.get_mut::<AssetStorage<Shader>>().unwrap();
         let mut builder = PipelineBuilder::new(name, &mut shader_storage);
         build(&mut builder);
         let pipeline = builder.finish();
         let pipeline_descriptor_handle = pipeline_descriptor_storage.add(pipeline);
         pipeline_descriptor_storage.set_name(name, pipeline_descriptor_handle);
-        self.render_graph.as_mut().unwrap()
+        self.render_graph
+            .as_mut()
+            .unwrap()
             .add_pipeline(pass, pipeline_descriptor_handle);
 
         self
@@ -66,14 +77,18 @@ impl<'a> RenderGraphBuilder<'a> {
     where
         T: ResourceProvider + Send + Sync + 'static,
     {
-        self.render_graph.as_mut().unwrap()
+        self.render_graph
+            .as_mut()
+            .unwrap()
             .resource_providers
             .push(Box::new(resource_provider));
         self
     }
 
     pub fn add_texture(&mut self, name: &str, texture_descriptor: TextureDescriptor) -> &mut Self {
-        self.render_graph.as_mut().unwrap()
+        self.render_graph
+            .as_mut()
+            .unwrap()
             .queued_textures
             .push((name.to_string(), texture_descriptor));
         self
@@ -83,7 +98,9 @@ impl<'a> RenderGraphBuilder<'a> {
     where
         T: DrawTarget + Send + Sync + 'static,
     {
-        self.render_graph.as_mut().unwrap()
+        self.render_graph
+            .as_mut()
+            .unwrap()
             .draw_targets
             .insert(draw_target.get_name(), Box::new(draw_target));
         self

src/render/render_resource/resource_providers/mesh_resource_provider.rs

@@ -49,7 +49,8 @@ impl ResourceProvider for MeshResourceProvider {
         resources: &Resources,
     ) {
         let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        render_graph.set_vertex_buffer_descriptor(Vertex::get_vertex_buffer_descriptor().cloned().unwrap());
+        render_graph
+            .set_vertex_buffer_descriptor(Vertex::get_vertex_buffer_descriptor().cloned().unwrap());
     }
 
     fn update(&mut self, renderer: &mut dyn Renderer, world: &mut World, resources: &Resources) {

src/render/render_resource/resource_providers/ui_resource_provider.rs

@@ -113,7 +113,8 @@ impl ResourceProvider for UiResourceProvider {
         resources: &Resources,
     ) {
         let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        render_graph.set_vertex_buffer_descriptor(Rect::get_vertex_buffer_descriptor().cloned().unwrap());
+        render_graph
+            .set_vertex_buffer_descriptor(Rect::get_vertex_buffer_descriptor().cloned().unwrap());
     }
 
     fn update(&mut self, renderer: &mut dyn Renderer, world: &mut World, _resources: &Resources) {

src/render/render_resource/resource_providers/uniform_resource_provider.rs

@@ -547,7 +547,7 @@ where
         resources: &Resources,
     ) {
         // update batch resources. this needs to run in "finish_update" because batches aren't finalized across
-        // all members of the batch until "UniformResourceProvider.update" has run for all members of the batch 
+        // all members of the batch until "UniformResourceProvider.update" has run for all members of the batch
         if let Some(asset_storage) = resources.get::<AssetStorage<T>>() {
             let mut asset_batchers = resources.get_mut::<AssetBatchers>().unwrap();
             let mut render_resource_assignments_provider = resources