cargo fmt

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/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::{
-            state_descriptors::{
         BlendDescriptor, ColorStateDescriptor, ColorWrite, CompareFunction, CullMode,
         DepthStencilStateDescriptor, FrontFace, RasterizationStateDescriptor,
         StencilStateFaceDescriptor,
     },
-        },
     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) {