cargo fmt

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>) {
+fn create_entities_builder_add_component(
-    world.build()
+    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>) {
+fn create_entities_builder_archetype(
-    world.build()
+    world: &mut World,
+    plane_handle: Handle<Mesh>,
+    cube_handle: Handle<Mesh>,
+) {
+    world
+        .build()
         // plane
         .add_archetype(MeshEntity {
             mesh: plane_handle.clone(),

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>()];
 

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(),

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,
+            ),
         });
     }
 

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(),

examples/simple_new_graph.rs

@@ -1,10 +1,15 @@
 use bevy::prelude::*;
-use bevy::render::render_graph_2::{StandardMaterial, ShaderUniforms, uniform_selector};
+use bevy::render::render_graph_2::{uniform_selector, ShaderUniforms, StandardMaterial};
-use std::collections::VecDeque;
 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,
+            ),
         })
     }
 

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) {

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) {

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(
         (),

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
+                        render_graph.resize(size.width, size.height, &mut self.world);
-                            .resize(size.width, size.height, &mut self.world);
                     }
 
                     if let Some(ref mut renderer) = self.renderer {
-                        renderer
+                        renderer.resize(
-                            .resize(&mut self.world, &mut self.render_graph, size.width, size.height);
+                            &mut self.world,
+                            &mut self.render_graph,
+                            size.width,
+                            size.height,
+                        );
                     }
                 }
                 event::Event::WindowEvent { event, .. } => match event {

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 {

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)]

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(
+            Some(children) => Some(for child in children.iter() {
-                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(
+            Some(children) => Some(for child in children.iter() {
-                for child in children.iter() {
                 run_on_hierarchy_subworld(world, *child, result, func);
-                }
+            }),
-            ),
             None => None,
         };
     }

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;

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};

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;

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);
 

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);

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(

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;
             };

src/render/render_graph_2/draw_targets/ui_draw_target.rs

@@ -1,9 +1,7 @@
 use crate::{
     asset::{AssetStorage, Mesh},
     legion::prelude::*,
-    render::{
+    render::render_graph_2::{resource_name, RenderPass, ResourceInfo},
-        render_graph_2::{RenderPass, resource_name, 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);

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::*;

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 {

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},
 };
 

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,
+            mesh_draw_target, pipeline_layout::*, PipelineDescriptor, RenderGraphBuilder,
-            RenderGraphBuilder,
         },
         shader::{Shader, ShaderStage},
     },
@@ -24,19 +23,16 @@ impl ForwardPipelineBuilder for RenderGraphBuilder {
                 include_str!("forward.frag"),
                 ShaderStage::Fragment,
             ))
-            .add_bind_group(BindGroup::new(
+            .add_bind_group(BindGroup::new(vec![
-                vec![
                 Binding {
                     name: "Camera".to_string(),
                     bind_type: BindType::Uniform {
                         dynamic: false,
-                            properties: vec![
+                        properties: vec![UniformProperty {
-                                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(
+            .add_bind_group(BindGroup::new(vec![
-                vec![
                 Binding {
                     name: "Object".to_string(),
                     bind_type: BindType::Uniform {
                         dynamic: true,
-                            properties: vec![
+                        properties: vec![UniformProperty {
-                                UniformProperty {
                             name: "Model".to_string(),
                             property_type: UniformPropertyType::Mat4,
+                        }],
                     },
-                            ]
-                        }
                 },
                 Binding {
                     name: "StandardMaterial".to_string(),
                     bind_type: BindType::Uniform {
                         dynamic: true,
-                            properties: vec![
+                        properties: vec![UniformProperty {
-                                UniformProperty {
                             name: "Albedo".to_string(),
                             property_type: UniformPropertyType::Vec4,
+                        }],
                     },
-                            ]
-                        }
                 },
-                ]
+            ]))
-            ))
             .with_rasterization_state(wgpu::RasterizationStateDescriptor {
                 front_face: wgpu::FrontFace::Ccw,
                 cull_mode: wgpu::CullMode::Back,

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,
+            mesh_draw_target, pipeline_layout::*, PipelineDescriptor, RenderGraphBuilder,
-            RenderGraphBuilder,
         },
         shader::{Shader, ShaderStage},
     },
@@ -24,50 +23,38 @@ impl ForwardFlatPipelineBuilder for RenderGraphBuilder {
                 include_str!("forward_flat.frag"),
                 ShaderStage::Fragment,
             ))
-            .add_bind_group(BindGroup::new(
+            .add_bind_group(BindGroup::new(vec![Binding {
-                vec![
-                    Binding {
                 name: "Camera".to_string(),
                 bind_type: BindType::Uniform {
                     dynamic: false,
-                            properties: vec![
+                    properties: vec![UniformProperty {
-                                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![
+                        properties: vec![UniformProperty {
-                                UniformProperty {
                             name: "Model".to_string(),
                             property_type: UniformPropertyType::Mat4,
+                        }],
                     },
-                            ]
-                        }
                 },
                 Binding {
                     name: "StandardMaterial".to_string(),
                     bind_type: BindType::Uniform {
                         dynamic: true,
-                            properties: vec![
+                        properties: vec![UniformProperty {
-                                UniformProperty {
                             name: "Albedo".to_string(),
                             property_type: UniformPropertyType::Vec4,
+                        }],
                     },
-                            ]
-                        }
                 },
-                ]
+            ]))
-            ))
             .with_rasterization_state(wgpu::RasterizationStateDescriptor {
                 front_face: wgpu::FrontFace::Ccw,
                 cull_mode: wgpu::CullMode::Back,

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(
+            .add_bind_group(BindGroup::new(vec![Binding {
-                vec![
-                    Binding {
                 name: "Camera2d".to_string(),
                 bind_type: BindType::Uniform {
                     dynamic: false,
-                            properties: vec![
+                    properties: vec![UniformProperty {
-                                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(
+            .add_vertex_buffer_descriptor(VertexBufferDescriptor {
-                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(),
         )

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
     }
 

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(
-    fn create_instance_buffer_with_data(&mut self, name: &str, mesh_id: usize, data: &[u8], size: usize, count: usize, buffer_usage: wgpu::BufferUsage);
+        &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,

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,
+        resource_name, BindGroup, BindType, DynamicUniformBufferInfo, PassDescriptor,
-        RenderPass, RenderPassColorAttachmentDescriptor,
+        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(

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 {

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
+        for (mut camera, _) in <(Write<Camera>, Read<ActiveCamera2d>)>::query().iter_mut(world) {
-            <(Write<Camera>, Read<ActiveCamera2d>)>::query().iter_mut(world)
-        {
             camera.update(width, height);
-            let camera_matrix: [[f32; 4]; 4] =
+            let camera_matrix: [[f32; 4]; 4] = camera.view_matrix.to_cols_array_2d();
-                camera.view_matrix.to_cols_array_2d();
 
             renderer.create_buffer_mapped(
                 "camera2d_tmp",

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;
 

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);
     }
 }

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 =
+        let light_uniform_size = (std::mem::size_of::<LightCount>()
-            (std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>()) as wgpu::BufferAddress;
+            + 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
+            renderer.create_buffer_mapped(
-                .create_buffer_mapped("LIGHT_TMP", total_size, wgpu::BufferUsage::COPY_SRC, &mut |data| {
+                "LIGHT_TMP",
-                    for ((light, local_to_world, translation), slot) in light_query
+                total_size,
-                        .iter(world)
+                wgpu::BufferUsage::COPY_SRC,
-                        .zip(data.chunks_exact_mut(size))
+                &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,
+    ) {
+    }
 }

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 ui_resource_provider;
-mod camera2d_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 ui_resource_provider::*;
-pub use camera2d_resource_provider::*;

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 {
+        UiResourceProvider { quad: None }
-            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,
+    ) {
     }
 }

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 {

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(
+    let binary_result = compiler
-        glsl_source, shader_kind,
+        .compile_into_spirv(
-        "shader.glsl", "main", Some(&options)).unwrap();
+            glsl_source,
+            shader_kind,
+            "shader.glsl",
+            "main",
+            Some(&options),
+        )
+        .unwrap();
 
     binary_result.as_binary().into()
 }

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)]

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)),