cargo fmt

2020-02-07 23:17:51 -08:00 · 2020-02-07 23:17:51 -08:00 · 3b0b40a79d
commit 3b0b40a79d
parent f68909ac00
52 changed files with 529 additions and 406 deletions
--- a/examples/entity_builder_comparison.rs
+++ b/examples/entity_builder_comparison.rs
@ -1,11 +1,18 @@
 use bevy::prelude::*;

 fn main() {
-    AppBuilder::new().add_defaults_legacy().setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults_legacy()
+        .setup_world(setup)
+        .run();
 }

 #[allow(dead_code)]
-fn create_entities_insert_vec(world: &mut World, plane_handle: Handle<Mesh>, cube_handle: Handle<Mesh>) {
+fn create_entities_insert_vec(
+    world: &mut World,
+    plane_handle: Handle<Mesh>,
+    cube_handle: Handle<Mesh>,
+) {
    // plane
    world.insert(
        (),
@ -70,8 +77,13 @@ fn create_entities_insert_vec(world: &mut World, plane_handle: Handle<Mesh>, cub
 }

 #[allow(dead_code)]
-fn create_entities_builder_add_component(world: &mut World, plane_handle: Handle<Mesh>, cube_handle: Handle<Mesh>) {
-    world.build()
+fn create_entities_builder_add_component(
+    world: &mut World,
+    plane_handle: Handle<Mesh>,
+    cube_handle: Handle<Mesh>,
+) {
+    world
+        .build()
        // plane
        .build_entity()
        .add(plane_handle.clone())
@ -117,8 +129,13 @@ fn create_entities_builder_add_component(world: &mut World, plane_handle: Handle
        .build();
 }

-fn create_entities_builder_archetype(world: &mut World, plane_handle: Handle<Mesh>, cube_handle: Handle<Mesh>) {
-    world.build()
+fn create_entities_builder_archetype(
+    world: &mut World,
+    plane_handle: Handle<Mesh>,
+    cube_handle: Handle<Mesh>,
+) {
+    world
+        .build()
        // plane
        .add_archetype(MeshEntity {
            mesh: plane_handle.clone(),
--- a/examples/serializing.rs
+++ b/examples/serializing.rs
@ -2,7 +2,10 @@ use bevy::{prelude::*, serialization::*};
 use serde::{Deserialize, Serialize};
 use type_uuid::TypeUuid;
 fn main() {
-    let app = AppBuilder::new().add_defaults_legacy().setup_world(setup).build();
+    let app = AppBuilder::new()
+        .add_defaults_legacy()
+        .setup_world(setup)
+        .build();

    let comp_registrations = [ComponentRegistration::of::<Test>()];

--- a/examples/simple.rs
+++ b/examples/simple.rs
@ -1,7 +1,10 @@
 use bevy::prelude::*;

 fn main() {
-    AppBuilder::new().add_defaults_legacy().setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults_legacy()
+        .setup_world(setup)
+        .run();
 }

 fn setup(world: &mut World) {
@ -13,7 +16,8 @@ fn setup(world: &mut World) {
        (mesh_storage.add(cube), mesh_storage.add(plane))
    };

-    world.build()
+    world
+        .build()
        // plane
        .add_archetype(MeshEntity {
            mesh: plane_handle.clone(),
--- a/examples/simple_legacy_comparison.rs
+++ b/examples/simple_legacy_comparison.rs
@ -1,8 +1,13 @@
 use bevy::prelude::*;
-use std::collections::VecDeque;
 use rand::{rngs::StdRng, Rng, SeedableRng};
+use std::collections::VecDeque;
 fn main() {
-    AppBuilder::new().add_defaults_legacy().add_system(build_move_system()).add_system(build_print_status_system()).setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults_legacy()
+        .add_system(build_move_system())
+        .add_system(build_print_status_system())
+        .setup_world(setup)
+        .run();
 }

 fn build_move_system() -> Box<dyn Schedulable> {
@ -54,7 +59,8 @@ fn setup(world: &mut World) {
        (mesh_storage.add(cube), mesh_storage.add(plane))
    };

-    let mut builder = world.build()
+    let mut builder = world
+        .build()
        // plane
        .add_archetype(MeshEntity {
            mesh: plane_handle.clone(),
@ -108,7 +114,11 @@ fn setup(world: &mut World) {
            mesh: cube_handle.clone(),
            material: Material::new(Albedo::Color(math::vec4(0.5, 0.3, 0.3, 1.0))),
            local_to_world: LocalToWorld::identity(),
-            translation: Translation::new(rng.gen_range(-50.0, 50.0), rng.gen_range(-50.0, 50.0), 0.0),
+            translation: Translation::new(
+                rng.gen_range(-50.0, 50.0),
+                rng.gen_range(-50.0, 50.0),
+                0.0,
+            ),
        });
    }

--- a/examples/simple_new.rs
+++ b/examples/simple_new.rs
@ -1,5 +1,5 @@
 use bevy::prelude::*;
-use bevy::render::render_graph_2::{StandardMaterial, ShaderUniforms};
+use bevy::render::render_graph_2::{ShaderUniforms, StandardMaterial};

 fn main() {
    AppBuilder::new().add_defaults().setup_world(setup).run();
@ -14,7 +14,8 @@ fn setup(world: &mut World) {
        (mesh_storage.add(cube), mesh_storage.add(plane))
    };

-    world.build()
+    world
+        .build()
        // plane
        .add_archetype(NewMeshEntity {
            mesh: plane_handle.clone(),
--- a/examples/simple_new_graph.rs
+++ b/examples/simple_new_graph.rs
@ -1,10 +1,15 @@
 use bevy::prelude::*;
-use bevy::render::render_graph_2::{StandardMaterial, ShaderUniforms, uniform_selector};
-use std::collections::VecDeque;
+use bevy::render::render_graph_2::{uniform_selector, ShaderUniforms, StandardMaterial};
 use rand::{rngs::StdRng, Rng, SeedableRng};
+use std::collections::VecDeque;

 fn main() {
-    AppBuilder::new().add_defaults().add_system(build_move_system()).add_system(build_print_status_system()).setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults()
+        .add_system(build_move_system())
+        .add_system(build_print_status_system())
+        .setup_world(setup)
+        .run();
 }

 fn build_move_system() -> Box<dyn Schedulable> {
@ -14,7 +19,13 @@ fn build_move_system() -> Box<dyn Schedulable> {
        .build(move |_, world, time, person_query| {
            for (mut translation, mut material) in person_query.iter_mut(world) {
                translation.0 += math::vec3(1.0, 0.0, 0.0) * time.delta_seconds;
-                material.albedo = material.albedo + math::vec4(-time.delta_seconds, -time.delta_seconds, time.delta_seconds, 0.0);
+                material.albedo = material.albedo
+                    + math::vec4(
+                        -time.delta_seconds,
+                        -time.delta_seconds,
+                        time.delta_seconds,
+                        0.0,
+                    );
            }
        })
 }
@ -57,7 +68,8 @@ fn setup(world: &mut World) {
        (mesh_storage.add(cube), mesh_storage.add(plane))
    };

-    let mut builder = world.build()
+    let mut builder = world
+        .build()
        // plane
        .add_archetype(NewMeshEntity {
            mesh: plane_handle.clone(),
@ -137,11 +149,15 @@ fn setup(world: &mut World) {

    let mut rng = StdRng::from_entropy();
    for _ in 0..10000 {
-
        builder = builder.add_archetype(NewMeshEntity {
            mesh: cube_handle.clone(),
            material: StandardMaterial {
-                albedo: math::vec4(rng.gen_range(0.0, 1.0), rng.gen_range(0.0, 1.0), rng.gen_range(0.0, 1.0), 1.0),
+                albedo: math::vec4(
+                    rng.gen_range(0.0, 1.0),
+                    rng.gen_range(0.0, 1.0),
+                    rng.gen_range(0.0, 1.0),
+                    1.0,
+                ),
            },
            shader_uniforms: ShaderUniforms {
                uniform_selectors: vec![
@ -150,7 +166,11 @@ fn setup(world: &mut World) {
                ],
            },
            local_to_world: LocalToWorld::identity(),
-            translation: Translation::new(rng.gen_range(-50.0, 50.0), rng.gen_range(-50.0, 50.0), 0.0),
+            translation: Translation::new(
+                rng.gen_range(-50.0, 50.0),
+                rng.gen_range(-50.0, 50.0),
+                0.0,
+            ),
        })
    }

--- a/examples/texture.rs
+++ b/examples/texture.rs
@ -1,7 +1,10 @@
 use bevy::{asset, prelude::*};

 fn main() {
-    AppBuilder::new().add_defaults_legacy().setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults_legacy()
+        .setup_world(setup)
+        .run();
 }

 fn setup(world: &mut World) {
--- a/examples/ui.rs
+++ b/examples/ui.rs
@ -1,7 +1,10 @@
 use bevy::prelude::*;

 fn main() {
-    AppBuilder::new().add_defaults_legacy().setup_world(setup).run();
+    AppBuilder::new()
+        .add_defaults_legacy()
+        .setup_world(setup)
+        .run();
 }

 fn setup(world: &mut World) {
--- a/examples/ui_new.rs
+++ b/examples/ui_new.rs
@ -1,5 +1,5 @@
 use bevy::prelude::*;
-use bevy::render::render_graph_2::{StandardMaterial, ShaderUniforms};
+use bevy::render::render_graph_2::{ShaderUniforms, StandardMaterial};

 fn main() {
    AppBuilder::new().add_defaults().setup_world(setup).run();
@ -12,7 +12,8 @@ fn setup(world: &mut World) {
        mesh_storage.add(cube)
    };

-    world.build()
+    world
+        .build()
        // cube
        .add_archetype(NewMeshEntity {
            mesh: cube_handle.clone(),
@ -69,7 +70,6 @@ fn setup(world: &mut World) {
        })
        .build();

-
    // bottom left anchor with vertical fill
    world.insert(
        (),
--- a/src/app/app.rs
+++ b/src/app/app.rs
@ -6,7 +6,12 @@ use winit::{

 use legion::prelude::*;

-use crate::{core::Time, render, app::AppBuilder, render::render_graph_2::{Renderer, RenderGraph}};
+use crate::{
+    app::AppBuilder,
+    core::Time,
+    render,
+    render::render_graph_2::{RenderGraph, Renderer},
+};

 pub struct App {
    pub universe: Universe,
@ -95,13 +100,16 @@ impl App {
                    ..
                } => {
                    if let Some(ref mut render_graph) = self.legacy_render_graph {
-                        render_graph
-                            .resize(size.width, size.height, &mut self.world);
+                        render_graph.resize(size.width, size.height, &mut self.world);
                    }

                    if let Some(ref mut renderer) = self.renderer {
-                        renderer
-                            .resize(&mut self.world, &mut self.render_graph, size.width, size.height);
+                        renderer.resize(
+                            &mut self.world,
+                            &mut self.render_graph,
+                            size.width,
+                            size.height,
+                        );
                    }
                }
                event::Event::WindowEvent { event, .. } => match event {
--- a/src/app/app_builder.rs
+++ b/src/app/app_builder.rs
@ -1,16 +1,19 @@
 use crate::{
-    app::{App, system_stage},
+    app::{system_stage, App},
    asset::*,
    core::Time,
    legion::prelude::{Runnable, Schedulable, Schedule, Universe, World},
-    render::render_graph_2,
-    render::render_graph_2::{pipelines::*, passes::*, renderers::wgpu_renderer::WgpuRenderer, resource_providers::*, UniformResourceProvider, StandardMaterial},
-    render::{passes::*, *},
    plugin::load_plugin,
+    render::render_graph_2,
+    render::render_graph_2::{
+        passes::*, pipelines::*, renderers::wgpu_renderer::WgpuRenderer, resource_providers::*,
+        StandardMaterial, UniformResourceProvider,
+    },
+    render::{passes::*, *},
    ui,
 };

-use bevy_transform::{transform_system_bundle, prelude::LocalToWorld};
+use bevy_transform::{prelude::LocalToWorld, transform_system_bundle};
 use std::collections::HashMap;

 pub struct AppBuilder {
--- a/src/ecs/default_archetypes.rs
+++ b/src/ecs/default_archetypes.rs
@ -1,5 +1,5 @@
 use crate::prelude::*;
-use crate::render::render_graph_2::{StandardMaterial, ShaderUniforms};
+use crate::render::render_graph_2::{ShaderUniforms, StandardMaterial};
 use bevy_derive::EntityArchetype;

 #[derive(EntityArchetype)]
--- a/src/ecs/mod.rs
+++ b/src/ecs/mod.rs
@ -1,12 +1,15 @@
-mod entity_builder;
-mod entity_archetype;
 pub mod default_archetypes;
+mod entity_archetype;
+mod entity_builder;

-pub use entity_builder::*;
 pub use entity_archetype::*;
+pub use entity_builder::*;

-use legion::{prelude::{Entity, World}, system::SubWorld};
 use bevy_transform::prelude::Children;
+use legion::{
+    prelude::{Entity, World},
+    system::SubWorld,
+};

 pub fn run_on_hierarchy<T>(
    world: &World,
@ -20,11 +23,9 @@ pub fn run_on_hierarchy<T>(

    if let Some(result) = result {
        match world.get_component::<Children>(entity) {
-            Some(children) => Some(
-                for child in children.iter() {
+            Some(children) => Some(for child in children.iter() {
                run_on_hierarchy(world, *child, result, func);
-                }
-            ),
+            }),
            None => None,
        };
    }
@ -72,11 +73,9 @@ pub fn run_on_hierarchy_subworld<T>(

    if let Some(result) = result {
        match world.get_component::<Children>(entity) {
-            Some(children) => Some(
-                for child in children.iter() {
+            Some(children) => Some(for child in children.iter() {
                run_on_hierarchy_subworld(world, *child, result, func);
-                }
-            ),
+            }),
            None => None,
        };
    }
--- a/src/lib.rs
+++ b/src/lib.rs
@ -1,14 +1,14 @@
 pub mod app;
 pub mod asset;
-pub mod ecs;
 pub mod core;
+pub mod ecs;
+pub mod plugin;
 pub mod prelude;
 pub mod render;
 pub mod serialization;
 pub mod ui;
-pub mod plugin;

+pub use bevy_transform as transform;
 pub use glam as math;
 pub use legion;
-pub use bevy_transform as transform;
 pub use wgpu;
--- a/src/prelude.rs
+++ b/src/prelude.rs
@ -3,13 +3,14 @@ pub use crate::{
    asset::{Asset, AssetStorage, Handle, Mesh, MeshType, Texture, TextureType},
    core::Time,
    ecs,
-    ecs::{EntityArchetype, EntityBuilder, EntityBuilderSource},
    ecs::default_archetypes::*,
+    ecs::{EntityArchetype, EntityBuilder, EntityBuilderSource},
    render::{
        ActiveCamera, ActiveCamera2d, Albedo, Camera, CameraType, Instanced, Light, Material,
    },
    ui::{Anchors, Margins, Node},
 };
+pub use bevy_transform::prelude::*;
 pub use glam as math;
 pub use legion::{
    prelude::*,
@ -17,5 +18,4 @@ pub use legion::{
    system::SubWorld,
    system::SystemBuilder,
 };
-pub use bevy_transform::prelude::*;
 pub use math::{Mat3, Mat4, Quat, Vec2, Vec3, Vec4};
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@ -1,9 +1,9 @@
 pub mod camera;
 pub mod instancing;
 pub mod passes;
+pub mod render_graph_2;
 pub mod render_resources;
 pub mod shader;
-pub mod render_graph_2;

 mod light;
 mod material;
--- a/src/render/passes/forward/forward_pipeline.rs
+++ b/src/render/passes/forward/forward_pipeline.rs
@ -22,7 +22,8 @@ impl ForwardPipeline {

 impl Pipeline for ForwardPipeline {
    fn initialize(&mut self, render_graph: &mut RenderGraphData, _: &mut World) {
-        let vs_bytes = shader::glsl_to_spirv(include_str!("forward.vert"), shader::ShaderStage::Vertex);
+        let vs_bytes =
+            shader::glsl_to_spirv(include_str!("forward.vert"), shader::ShaderStage::Vertex);
        let fs_bytes =
            shader::glsl_to_spirv(include_str!("forward.frag"), shader::ShaderStage::Fragment);

--- a/src/render/passes/shadow/shadow_pipeline.rs
+++ b/src/render/passes/shadow/shadow_pipeline.rs
@ -102,7 +102,8 @@ impl Pipeline for ShadowPipeline {
        let vertex_buffer_descriptor = get_vertex_buffer_descriptor();

        // Create the render pipeline
-        let vs_bytes = shader::glsl_to_spirv(include_str!("shadow.vert"), shader::ShaderStage::Vertex);
+        let vs_bytes =
+            shader::glsl_to_spirv(include_str!("shadow.vert"), shader::ShaderStage::Vertex);
        let fs_bytes =
            shader::glsl_to_spirv(include_str!("shadow.frag"), shader::ShaderStage::Fragment);
        let vs_module = render_graph.device.create_shader_module(&vs_bytes);
--- a/src/render/passes/ui/mod.rs
+++ b/src/render/passes/ui/mod.rs
@ -96,7 +96,8 @@ impl UiPipeline {
 impl Pipeline for UiPipeline {
    fn initialize(&mut self, render_graph: &mut RenderGraphData, world: &mut World) {
        let vs_bytes = shader::glsl_to_spirv(include_str!("ui.vert"), shader::ShaderStage::Vertex);
-        let fs_bytes = shader::glsl_to_spirv(include_str!("ui.frag"), shader::ShaderStage::Fragment);
+        let fs_bytes =
+            shader::glsl_to_spirv(include_str!("ui.frag"), shader::ShaderStage::Fragment);

        let bind_group_layout =
            render_graph
@ -225,8 +226,7 @@ impl Pipeline for UiPipeline {
            alpha_to_coverage_enabled: false,
        };

-        self.pipeline = Some(render_graph.device.create_render_pipeline(&pipedesc
-        ));
+        self.pipeline = Some(render_graph.device.create_render_pipeline(&pipedesc));
    }

    fn render(
--- a/src/render/render_graph_2/draw_target.rs
+++ b/src/render/render_graph_2/draw_target.rs
@ -2,7 +2,7 @@ use crate::{
    asset::{AssetStorage, Handle, Mesh},
    legion::prelude::*,
    render::{
-        render_graph_2::{RenderPass, ShaderUniforms, resource_name},
+        render_graph_2::{resource_name, RenderPass, ShaderUniforms},
        Instanced,
    },
 };
@ -42,7 +42,11 @@ pub fn mesh_draw_target(world: &World, render_pass: &mut dyn RenderPass) {

                // TODO: Verify buffer format matches render pass
                render_pass.set_index_buffer(resource_name::buffer::TEMP_MESH_INDEX_BUFFER_NAME, 0);
-                render_pass.set_vertex_buffer(0, resource_name::buffer::TEMP_MESH_VERTEX_BUFFER_NAME, 0);
+                render_pass.set_vertex_buffer(
+                    0,
+                    resource_name::buffer::TEMP_MESH_VERTEX_BUFFER_NAME,
+                    0,
+                );
                current_mesh_id = Some(mesh.id);
                current_mesh_index_length = mesh_asset.indices.len() as u32;
            };
--- a/src/render/render_graph_2/draw_targets/ui_draw_target.rs
+++ b/src/render/render_graph_2/draw_targets/ui_draw_target.rs
@ -1,9 +1,7 @@
 use crate::{
    asset::{AssetStorage, Mesh},
    legion::prelude::*,
-    render::{
-        render_graph_2::{RenderPass, resource_name, ResourceInfo},
-    },
+    render::render_graph_2::{resource_name, RenderPass, ResourceInfo},
 };

 use zerocopy::AsBytes;
@ -40,7 +38,6 @@ pub fn ui_draw_target(world: &World, render_pass: &mut dyn RenderPass) {
        } else {
            None
        }
-
    };
    if let Some((instance_count, indices_length)) = result {
        render_pass.setup_bind_groups(None);
--- a/src/render/render_graph_2/mod.rs
+++ b/src/render/render_graph_2/mod.rs
@ -1,25 +1,25 @@
+mod draw_target;
+pub mod draw_targets;
+mod pass;
+pub mod passes;
+mod pipeline;
+mod pipeline_layout;
 pub mod pipelines;
+mod render_graph;
+mod renderer;
+pub mod renderers;
+mod resource;
 pub mod resource_name;
 pub mod resource_provider;
 pub mod resource_providers;
-pub mod passes;
-pub mod draw_targets;
-pub mod renderers;
-mod resource;
-mod pipeline;
-mod pipeline_layout;
-mod pass;
-mod renderer;
 mod shader;
-mod render_graph;
-mod draw_target;

+pub use draw_target::*;
+pub use pass::*;
 pub use pipeline::*;
 pub use pipeline_layout::*;
-pub use pass::*;
-pub use renderer::*;
-pub use shader::*;
 pub use render_graph::*;
-pub use draw_target::*;
+pub use renderer::*;
 pub use resource::*;
 pub use resource_provider::*;
+pub use shader::*;
--- a/src/render/render_graph_2/passes/forward.rs
+++ b/src/render/render_graph_2/passes/forward.rs
@ -1,7 +1,7 @@
 use crate::render::render_graph_2::{
-    resource_name, PassDescriptor, RenderGraphBuilder, RenderPassColorAttachmentDescriptor,
+    resource_name, resource_providers::FrameTextureResourceProvider, PassDescriptor,
+    RenderGraphBuilder, RenderPassColorAttachmentDescriptor,
    RenderPassDepthStencilAttachmentDescriptor, TextureDescriptor, TextureDimension,
-    resource_providers::FrameTextureResourceProvider,
 };

 pub trait ForwardPassBuilder {
@ -10,7 +10,9 @@ pub trait ForwardPassBuilder {

 impl ForwardPassBuilder for RenderGraphBuilder {
    fn add_forward_pass(self) -> Self {
-        self.add_resource_provider(Box::new(FrameTextureResourceProvider::new(resource_name::texture::DEPTH, TextureDescriptor {
+        self.add_resource_provider(Box::new(FrameTextureResourceProvider::new(
+            resource_name::texture::DEPTH,
+            TextureDescriptor {
                size: wgpu::Extent3d {
                    depth: 1,
                    width: 1,
@ -22,7 +24,8 @@ impl ForwardPassBuilder for RenderGraphBuilder {
                dimension: TextureDimension::D2,
                format: wgpu::TextureFormat::Depth32Float,
                usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
-        })))
+            },
+        )))
        .add_pass(
            "main",
            PassDescriptor {
--- a/src/render/render_graph_2/pipeline.rs
+++ b/src/render/render_graph_2/pipeline.rs
@ -1,5 +1,5 @@
 use crate::render::{
-    render_graph_2::{DrawTarget, PipelineLayout, BindGroup},
+    render_graph_2::{BindGroup, DrawTarget, PipelineLayout},
    shader::{Shader, ShaderStages},
 };

--- a/src/render/render_graph_2/pipelines/forward/mod.rs
+++ b/src/render/render_graph_2/pipelines/forward/mod.rs
@ -2,8 +2,7 @@ use crate::render::{
    Vertex,
    {
        render_graph_2::{
-            mesh_draw_target, pipeline_layout::*, PipelineDescriptor,
-            RenderGraphBuilder,
+            mesh_draw_target, pipeline_layout::*, PipelineDescriptor, RenderGraphBuilder,
        },
        shader::{Shader, ShaderStage},
    },
@ -24,19 +23,16 @@ impl ForwardPipelineBuilder for RenderGraphBuilder {
                include_str!("forward.frag"),
                ShaderStage::Fragment,
            ))
-            .add_bind_group(BindGroup::new(
-                vec![
+            .add_bind_group(BindGroup::new(vec![
                Binding {
                    name: "Camera".to_string(),
                    bind_type: BindType::Uniform {
                        dynamic: false,
-                            properties: vec![
-                                UniformProperty {
+                        properties: vec![UniformProperty {
                            name: "ViewProj".to_string(),
                            property_type: UniformPropertyType::Mat4,
+                        }],
                    },
-                            ]
-                        }
                },
                Binding {
                    name: "Lights".to_string(),
@ -58,39 +54,32 @@ impl ForwardPipelineBuilder for RenderGraphBuilder {
                                    10, // max lights
                                ),
                            },
-                            ]
-                        }
+                        ],
                    },
-                ]
-            ))
-            .add_bind_group(BindGroup::new(
-                vec![
+                },
+            ]))
+            .add_bind_group(BindGroup::new(vec![
                Binding {
                    name: "Object".to_string(),
                    bind_type: BindType::Uniform {
                        dynamic: true,
-                            properties: vec![
-                                UniformProperty {
+                        properties: vec![UniformProperty {
                            name: "Model".to_string(),
                            property_type: UniformPropertyType::Mat4,
+                        }],
                    },
-                            ]
-                        }
                },
                Binding {
                    name: "StandardMaterial".to_string(),
                    bind_type: BindType::Uniform {
                        dynamic: true,
-                            properties: vec![
-                                UniformProperty {
+                        properties: vec![UniformProperty {
                            name: "Albedo".to_string(),
                            property_type: UniformPropertyType::Vec4,
+                        }],
                    },
-                            ]
-                        }
                },
-                ]
-            ))
+            ]))
            .with_rasterization_state(wgpu::RasterizationStateDescriptor {
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: wgpu::CullMode::Back,
--- a/src/render/render_graph_2/pipelines/forward_flat/mod.rs
+++ b/src/render/render_graph_2/pipelines/forward_flat/mod.rs
@ -2,8 +2,7 @@ use crate::render::{
    Vertex,
    {
        render_graph_2::{
-            mesh_draw_target, pipeline_layout::*, PipelineDescriptor,
-            RenderGraphBuilder,
+            mesh_draw_target, pipeline_layout::*, PipelineDescriptor, RenderGraphBuilder,
        },
        shader::{Shader, ShaderStage},
    },
@ -24,50 +23,38 @@ impl ForwardFlatPipelineBuilder for RenderGraphBuilder {
                include_str!("forward_flat.frag"),
                ShaderStage::Fragment,
            ))
-            .add_bind_group(BindGroup::new(
-                vec![
-                    Binding {
+            .add_bind_group(BindGroup::new(vec![Binding {
                name: "Camera".to_string(),
                bind_type: BindType::Uniform {
                    dynamic: false,
-                            properties: vec![
-                                UniformProperty {
+                    properties: vec![UniformProperty {
                        name: "ViewProj".to_string(),
                        property_type: UniformPropertyType::Mat4,
+                    }],
                },
-                            ]
-                        }
-                    },
-                ]
-            ))
-            .add_bind_group(BindGroup::new(
-                vec![
+            }]))
+            .add_bind_group(BindGroup::new(vec![
                Binding {
                    name: "Object".to_string(),
                    bind_type: BindType::Uniform {
                        dynamic: true,
-                            properties: vec![
-                                UniformProperty {
+                        properties: vec![UniformProperty {
                            name: "Model".to_string(),
                            property_type: UniformPropertyType::Mat4,
+                        }],
                    },
-                            ]
-                        }
                },
                Binding {
                    name: "StandardMaterial".to_string(),
                    bind_type: BindType::Uniform {
                        dynamic: true,
-                            properties: vec![
-                                UniformProperty {
+                        properties: vec![UniformProperty {
                            name: "Albedo".to_string(),
                            property_type: UniformPropertyType::Vec4,
+                        }],
                    },
-                            ]
-                        }
                },
-                ]
-            ))
+            ]))
            .with_rasterization_state(wgpu::RasterizationStateDescriptor {
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: wgpu::CullMode::Back,
--- a/src/render/render_graph_2/pipelines/ui/mod.rs
+++ b/src/render/render_graph_2/pipelines/ui/mod.rs
@ -1,16 +1,15 @@
+use crate::render::render_graph_2::resource_providers::RectData;
+use crate::render::render_graph_2::VertexBufferDescriptor;
 use crate::render::{
    Vertex,
    {
        render_graph_2::{
-            pipeline_layout::*, PipelineDescriptor,
+            draw_targets::ui_draw_target, pipeline_layout::*, PipelineDescriptor,
            RenderGraphBuilder,
-            draw_targets::ui_draw_target,
        },
        shader::{Shader, ShaderStage},
    },
 };
-use crate::render::render_graph_2::VertexBufferDescriptor;
-use crate::render::render_graph_2::resource_providers::RectData;
 pub trait UiPipelineBuilder {
    fn add_ui_pipeline(self) -> Self;
 }
@ -27,22 +26,16 @@ impl UiPipelineBuilder for RenderGraphBuilder {
                include_str!("ui.frag"),
                ShaderStage::Fragment,
            ))
-            .add_bind_group(BindGroup::new(
-                vec![
-                    Binding {
+            .add_bind_group(BindGroup::new(vec![Binding {
                name: "Camera2d".to_string(),
                bind_type: BindType::Uniform {
                    dynamic: false,
-                            properties: vec![
-                                UniformProperty {
+                    properties: vec![UniformProperty {
                        name: "ViewProj".to_string(),
                        property_type: UniformPropertyType::Mat4,
+                    }],
                },
-                            ]
-                        }
-                    },
-                ]
-            ))
+            }]))
            .with_rasterization_state(wgpu::RasterizationStateDescriptor {
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: wgpu::CullMode::None,
@ -74,8 +67,7 @@ impl UiPipelineBuilder for RenderGraphBuilder {
                write_mask: wgpu::ColorWrite::ALL,
            })
            .add_vertex_buffer_descriptor(Vertex::get_vertex_buffer_descriptor())
-            .add_vertex_buffer_descriptor(
-                VertexBufferDescriptor {
+            .add_vertex_buffer_descriptor(VertexBufferDescriptor {
                stride: std::mem::size_of::<RectData>() as u64,
                step_mode: wgpu::InputStepMode::Instance,
                attributes: vec![
@ -100,8 +92,7 @@ impl UiPipelineBuilder for RenderGraphBuilder {
                        shader_location: 6,
                    },
                ],
-                }
-            )
+            })
            .add_draw_target(ui_draw_target)
            .build(),
        )
--- a/src/render/render_graph_2/render_graph.rs
+++ b/src/render/render_graph_2/render_graph.rs
@ -1,4 +1,6 @@
-use crate::render::render_graph_2::{PassDescriptor, PipelineDescriptor, ResourceProvider, TextureDescriptor};
+use crate::render::render_graph_2::{
+    PassDescriptor, PipelineDescriptor, ResourceProvider, TextureDescriptor,
+};
 use std::collections::HashMap;

 pub struct RenderGraph {
@ -50,10 +52,16 @@ impl RenderGraphBuilder {

        if let Some(current_pass) = self.current_pass.as_ref() {
            if let None = self.render_graph.pass_pipelines.get(current_pass) {
-                self.render_graph.pass_pipelines.insert(current_pass.to_string(), Vec::new());
+                self.render_graph
+                    .pass_pipelines
+                    .insert(current_pass.to_string(), Vec::new());
            }

-            let pass_pipelines = self.render_graph.pass_pipelines.get_mut(current_pass).unwrap();
+            let pass_pipelines = self
+                .render_graph
+                .pass_pipelines
+                .get_mut(current_pass)
+                .unwrap();
            pass_pipelines.push(name.to_string());
        }

@ -66,7 +74,9 @@ impl RenderGraphBuilder {
    }

    pub fn add_texture(mut self, name: &str, texture_descriptor: TextureDescriptor) -> Self {
-        self.render_graph.queued_textures.push((name.to_string(), texture_descriptor));
+        self.render_graph
+            .queued_textures
+            .push((name.to_string(), texture_descriptor));
        self
    }

--- a/src/render/render_graph_2/renderer.rs
+++ b/src/render/render_graph_2/renderer.rs
@ -27,8 +27,23 @@ pub trait Renderer {
    ) -> Option<&mut DynamicUniformBufferInfo>;
    fn add_dynamic_uniform_buffer_info(&mut self, name: &str, info: DynamicUniformBufferInfo);
    fn create_buffer(&mut self, name: &str, size: u64, buffer_usage: wgpu::BufferUsage);
-    fn create_instance_buffer(&mut self, name: &str, mesh_id: usize, size: usize, count: usize, buffer_usage: wgpu::BufferUsage);
-    fn create_instance_buffer_with_data(&mut self, name: &str, mesh_id: usize, data: &[u8], size: usize, count: usize, buffer_usage: wgpu::BufferUsage);
+    fn create_instance_buffer(
+        &mut self,
+        name: &str,
+        mesh_id: usize,
+        size: usize,
+        count: usize,
+        buffer_usage: wgpu::BufferUsage,
+    );
+    fn create_instance_buffer_with_data(
+        &mut self,
+        name: &str,
+        mesh_id: usize,
+        data: &[u8],
+        size: usize,
+        count: usize,
+        buffer_usage: wgpu::BufferUsage,
+    );
    fn create_buffer_mapped(
        &mut self,
        name: &str,
--- a/src/render/render_graph_2/renderers/wgpu_renderer.rs
+++ b/src/render/render_graph_2/renderers/wgpu_renderer.rs
@ -1,10 +1,10 @@
 use crate::{
    legion::prelude::*,
    render::render_graph_2::{
-        resource_name, BindGroup, BindType, PassDescriptor, PipelineDescriptor, RenderGraph,
-        RenderPass, RenderPassColorAttachmentDescriptor,
+        resource_name, BindGroup, BindType, DynamicUniformBufferInfo, PassDescriptor,
+        PipelineDescriptor, RenderGraph, RenderPass, RenderPassColorAttachmentDescriptor,
        RenderPassDepthStencilAttachmentDescriptor, Renderer, ResourceInfo, ShaderUniforms,
-        TextureDescriptor, DynamicUniformBufferInfo,
+        TextureDescriptor,
    },
 };
 use std::{collections::HashMap, ops::Deref};
@ -235,7 +235,10 @@ impl WgpuRenderer {
            // if a uniform resource buffer doesn't exist, create a new empty one
            for binding in bind_group.bindings.iter() {
                if let None = self.resource_info.get(&binding.name) {
-                    println!("Warning: creating new empty buffer for binding {}", binding.name);
+                    println!(
+                        "Warning: creating new empty buffer for binding {}",
+                        binding.name
+                    );
                    unset_uniforms.push(binding.name.to_string());
                    if let BindType::Uniform { .. } = &binding.bind_type {
                        let size = binding.bind_type.get_uniform_size().unwrap();
@ -565,7 +568,14 @@ impl Renderer for WgpuRenderer {
        self.buffers.insert(name.to_string(), buffer);
    }

-    fn create_instance_buffer(&mut self, name: &str, mesh_id: usize, size: usize, count: usize, buffer_usage: wgpu::BufferUsage) {
+    fn create_instance_buffer(
+        &mut self,
+        name: &str,
+        mesh_id: usize,
+        size: usize,
+        count: usize,
+        buffer_usage: wgpu::BufferUsage,
+    ) {
        let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
            size: (size * count) as u64,
            usage: buffer_usage,
@ -584,7 +594,15 @@ impl Renderer for WgpuRenderer {
        self.buffers.insert(name.to_string(), buffer);
    }

-    fn create_instance_buffer_with_data(&mut self, name: &str, mesh_id: usize, data: &[u8], size: usize, count: usize, buffer_usage: wgpu::BufferUsage) {
+    fn create_instance_buffer_with_data(
+        &mut self,
+        name: &str,
+        mesh_id: usize,
+        data: &[u8],
+        size: usize,
+        count: usize,
+        buffer_usage: wgpu::BufferUsage,
+    ) {
        let buffer = self.device.create_buffer_with_data(data, buffer_usage);

        self.add_resource_info(
--- a/src/render/render_graph_2/resource.rs
+++ b/src/render/render_graph_2/resource.rs
@ -1,5 +1,5 @@
-use std::collections::HashMap;
 use legion::prelude::Entity;
+use std::collections::HashMap;

 pub enum ResourceInfo {
    BufferMapped {
--- a/src/render/render_graph_2/resource_providers/camera2d_resource_provider.rs
+++ b/src/render/render_graph_2/resource_providers/camera2d_resource_provider.rs
@ -1,10 +1,10 @@
-use crate::{render::{
+use crate::render::render_graph_2::ResourceProvider;
+use crate::render::{
    render_graph_2::{resource_name, Renderer},
    ActiveCamera2d, Camera,
-}};
+};
 use legion::prelude::*;
 use zerocopy::AsBytes;
-use crate::render::render_graph_2::ResourceProvider;

 pub struct Camera2dResourceProvider;

@ -20,12 +20,9 @@ impl ResourceProvider for Camera2dResourceProvider {
    fn update(&mut self, _renderer: &mut dyn Renderer, _world: &mut World) {}
    fn resize(&mut self, renderer: &mut dyn Renderer, world: &mut World, width: u32, height: u32) {
        let matrix_size = std::mem::size_of::<[[f32; 4]; 4]>();
-        for (mut camera, _) in
-            <(Write<Camera>, Read<ActiveCamera2d>)>::query().iter_mut(world)
-        {
+        for (mut camera, _) in <(Write<Camera>, Read<ActiveCamera2d>)>::query().iter_mut(world) {
            camera.update(width, height);
-            let camera_matrix: [[f32; 4]; 4] =
-                camera.view_matrix.to_cols_array_2d();
+            let camera_matrix: [[f32; 4]; 4] = camera.view_matrix.to_cols_array_2d();

            renderer.create_buffer_mapped(
                "camera2d_tmp",
--- a/src/render/render_graph_2/resource_providers/camera_resource_provider.rs
+++ b/src/render/render_graph_2/resource_providers/camera_resource_provider.rs
@ -1,11 +1,11 @@
-use crate::{render::{
+use crate::render::render_graph_2::ResourceProvider;
+use crate::render::{
    render_graph_2::{resource_name, Renderer},
    ActiveCamera, Camera,
-}};
+};
 use bevy_transform::prelude::LocalToWorld;
 use legion::prelude::*;
 use zerocopy::AsBytes;
-use crate::render::render_graph_2::ResourceProvider;

 pub struct CameraResourceProvider;

--- a/src/render/render_graph_2/resource_providers/frame_texture_resource_provider.rs
+++ b/src/render/render_graph_2/resource_providers/frame_texture_resource_provider.rs
@ -32,7 +32,13 @@ impl ResourceProvider for FrameTextureResourceProvider {

    fn update(&mut self, _renderer: &mut dyn Renderer, _world: &mut World) {}

-    fn resize(&mut self, renderer: &mut dyn Renderer, world: &mut World, _width: u32, _height: u32) {
+    fn resize(
+        &mut self,
+        renderer: &mut dyn Renderer,
+        world: &mut World,
+        _width: u32,
+        _height: u32,
+    ) {
        self.update(renderer, world);
    }
 }
--- a/src/render/render_graph_2/resource_providers/light_resource_provider.rs
+++ b/src/render/render_graph_2/resource_providers/light_resource_provider.rs
@ -1,10 +1,10 @@
-use zerocopy::AsBytes;
-use legion::prelude::*;
-use crate::render::render_graph_2::ResourceProvider;
 use crate::render::render_graph_2::resource_name;
 use crate::render::render_graph_2::Renderer;
+use crate::render::render_graph_2::ResourceProvider;
 use crate::render::{Light, LightRaw};
 use bevy_transform::prelude::{LocalToWorld, Translation};
+use legion::prelude::*;
+use zerocopy::AsBytes;

 pub struct LightResourceProvider {
    pub lights_are_dirty: bool,
@ -28,8 +28,9 @@ impl LightResourceProvider {

 impl ResourceProvider for LightResourceProvider {
    fn initialize(&mut self, renderer: &mut dyn Renderer, _world: &mut World) {
-        let light_uniform_size =
-            (std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>()) as wgpu::BufferAddress;
+        let light_uniform_size = (std::mem::size_of::<LightCount>()
+            + self.max_lights * std::mem::size_of::<LightRaw>())
+            as wgpu::BufferAddress;

        renderer.create_buffer(
            resource_name::uniform::LIGHTS,
@ -51,21 +52,28 @@ impl ResourceProvider for LightResourceProvider {
            let size = std::mem::size_of::<LightRaw>();
            let total_size = size * light_count;
            let light_count_size = std::mem::size_of::<LightCount>();
-            renderer
-                .create_buffer_mapped("LIGHT_TMP", total_size, wgpu::BufferUsage::COPY_SRC, &mut |data| {
-                    for ((light, local_to_world, translation), slot) in light_query
-                        .iter(world)
-                        .zip(data.chunks_exact_mut(size))
+            renderer.create_buffer_mapped(
+                "LIGHT_TMP",
+                total_size,
+                wgpu::BufferUsage::COPY_SRC,
+                &mut |data| {
+                    for ((light, local_to_world, translation), slot) in
+                        light_query.iter(world).zip(data.chunks_exact_mut(size))
                    {
                        slot.copy_from_slice(
                            LightRaw::from(&light, &local_to_world.0, &translation).as_bytes(),
                        );
                    }
-                });
-            renderer
-                .create_buffer_mapped("LIGHT_COUNT_TMP", light_count_size, wgpu::BufferUsage::COPY_SRC, &mut |data| {
+                },
+            );
+            renderer.create_buffer_mapped(
+                "LIGHT_COUNT_TMP",
+                light_count_size,
+                wgpu::BufferUsage::COPY_SRC,
+                &mut |data| {
                    data.copy_from_slice([light_count as u32, 0, 0, 0].as_bytes());
-                });
+                },
+            );

            renderer.copy_buffer_to_buffer(
                "LIGHT_COUNT_TMP",
@ -85,5 +93,12 @@ impl ResourceProvider for LightResourceProvider {
        }
    }

-    fn resize(&mut self, _renderer: &mut dyn Renderer, _world: &mut World, _width: u32, _height: u32) {}
+    fn resize(
+        &mut self,
+        _renderer: &mut dyn Renderer,
+        _world: &mut World,
+        _width: u32,
+        _height: u32,
+    ) {
+    }
 }
--- a/src/render/render_graph_2/resource_providers/mod.rs
+++ b/src/render/render_graph_2/resource_providers/mod.rs
@ -1,11 +1,11 @@
-mod ui_resource_provider;
+mod camera2d_resource_provider;
+mod camera_resource_provider;
 mod frame_texture_resource_provider;
 mod light_resource_provider;
-mod camera_resource_provider;
-mod camera2d_resource_provider;
+mod ui_resource_provider;

-pub use ui_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 camera_resource_provider::*;
-pub use camera2d_resource_provider::*;
+pub use ui_resource_provider::*;
--- a/src/render/render_graph_2/resource_providers/ui_resource_provider.rs
+++ b/src/render/render_graph_2/resource_providers/ui_resource_provider.rs
@ -1,11 +1,15 @@
+use crate::asset::MeshType;
 use crate::prelude::Node;
 use crate::render::render_graph_2::resource_name;
 use crate::render::render_graph_2::ResourceProvider;
-use crate::{ecs, render::render_graph_2::Renderer, asset::{Handle, Mesh, Asset, AssetStorage}, math};
+use crate::{
+    asset::{Asset, AssetStorage, Handle, Mesh},
+    ecs, math,
+    render::render_graph_2::Renderer,
+};
 use bevy_transform::prelude::Parent;
 use legion::prelude::*;
 use zerocopy::{AsBytes, FromBytes};
-use crate::asset::MeshType;

 #[repr(C)]
 #[derive(Clone, Copy, Debug, AsBytes, FromBytes)]
@ -22,9 +26,7 @@ pub struct UiResourceProvider {

 impl UiResourceProvider {
    pub fn new() -> Self {
-        UiResourceProvider {
-            quad: None,
-        }
+        UiResourceProvider { quad: None }
    }

    pub fn update(&mut self, renderer: &mut dyn Renderer, world: &World) {
@ -60,7 +62,7 @@ impl UiResourceProvider {
        }

        if data.len() == 0 {
-            return
+            return;
        }

        let size = std::mem::size_of::<RectData>();
@ -95,6 +97,12 @@ impl ResourceProvider for UiResourceProvider {
        self.update(renderer, world);
    }

-    fn resize(&mut self, _renderer: &mut dyn Renderer, _world: &mut World, _width: u32, _height: u32) {
+    fn resize(
+        &mut self,
+        _renderer: &mut dyn Renderer,
+        _world: &mut World,
+        _width: u32,
+        _height: u32,
+    ) {
    }
 }
--- a/src/render/render_graph_2/shader.rs
+++ b/src/render/render_graph_2/shader.rs
@ -9,8 +9,8 @@ use crate::{
    },
 };
 use legion::{prelude::*, storage::Component};
-use zerocopy::AsBytes;
 use std::marker::PhantomData;
+use zerocopy::AsBytes;

 pub type ShaderUniformSelector = fn(Entity, &World) -> Option<RefMap<&dyn AsUniforms>>;
 pub struct ShaderUniforms {
--- a/src/render/shader.rs
+++ b/src/render/shader.rs
@ -21,9 +21,15 @@ pub fn glsl_to_spirv(glsl_source: &str, stage: ShaderStage) -> Vec<u32> {
    let shader_kind: shaderc::ShaderKind = stage.into();
    let mut compiler = shaderc::Compiler::new().unwrap();
    let options = shaderc::CompileOptions::new().unwrap();
-    let binary_result = compiler.compile_into_spirv(
-        glsl_source, shader_kind,
-        "shader.glsl", "main", Some(&options)).unwrap();
+    let binary_result = compiler
+        .compile_into_spirv(
+            glsl_source,
+            shader_kind,
+            "shader.glsl",
+            "main",
+            Some(&options),
+        )
+        .unwrap();

    binary_result.as_binary().into()
 }
--- a/src/render/vertex.rs
+++ b/src/render/vertex.rs
@ -1,6 +1,6 @@
+use crate::render::render_graph_2::VertexBufferDescriptor;
 use std::convert::From;
 use zerocopy::{AsBytes, FromBytes};
-use crate::render::render_graph_2::VertexBufferDescriptor;

 #[repr(C)]
 #[derive(Clone, Copy, AsBytes, FromBytes)]
--- a/src/serialization/world.rs
+++ b/src/serialization/world.rs
@ -13,7 +13,7 @@ use serde::{
    Deserialize, Deserializer, Serialize, Serializer,
 };
 use std::{
-    any::{type_name}, cell::RefCell, collections::HashMap, iter::FromIterator, marker::PhantomData,
+    any::type_name, cell::RefCell, collections::HashMap, iter::FromIterator, marker::PhantomData,
    ptr::NonNull,
 };
 use type_uuid::TypeUuid;
@ -209,7 +209,9 @@ impl SerializeImpl {
                    .map(|reg| (reg.ty.clone(), reg.clone())),
            ),
            tag_types: HashMap::from_iter(
-                tag_registrations.iter().map(|reg| (reg.ty.clone(), reg.clone())),
+                tag_registrations
+                    .iter()
+                    .map(|reg| (reg.ty.clone(), reg.clone())),
            ),
            entity_map: RefCell::new(HashMap::new()),
        }
@ -227,7 +229,9 @@ impl SerializeImpl {
                    .map(|reg| (reg.ty.clone(), reg.clone())),
            ),
            tag_types: HashMap::from_iter(
-                tag_registrations.iter().map(|reg| (reg.ty.clone(), reg.clone())),
+                tag_registrations
+                    .iter()
+                    .map(|reg| (reg.ty.clone(), reg.clone())),
            ),
            entity_map: RefCell::new(HashMap::from_iter(
                entity_map.into_iter().map(|(uuid, e)| (e, uuid)),