cargo fmt

examples/setup_system.rs

@@ -1,7 +1,10 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build().add_default_plugins().add_setup_system(setup_system()).run();
+    App::build()
+        .add_default_plugins()
+        .add_setup_system(setup_system())
+        .run();
 }
 
 pub fn setup_system() -> Box<dyn Schedulable> {

src/app/app_builder.rs

@@ -5,9 +5,9 @@ use crate::{
     },
     core::{CorePlugin, Events},
     legion::prelude::{Resources, Runnable, Schedulable, Schedule, Universe, World},
-    window::WindowPlugin,
     render::RenderPlugin,
     ui::UiPlugin,
+    window::WindowPlugin,
 };
 
 use std::collections::HashMap;

src/app/mod.rs

@@ -1,8 +1,8 @@
 mod app;
 mod app_builder;
-pub mod system_stage;
 pub mod plugin;
 pub mod schedule_runner;
+pub mod system_stage;
 
 pub use app::App;
 pub use app_builder::AppBuilder;

src/app/schedule_runner.rs

@@ -6,17 +6,13 @@ use std::{thread, time::Duration};
 
 #[derive(Copy, Clone, Debug)]
 pub enum RunMode {
-    Loop {
+    Loop { wait: Option<Duration> },
-        wait: Option<Duration>,
-    },
     Once,
 }
 
 impl Default for RunMode {
     fn default() -> Self {
-        RunMode::Loop {
+        RunMode::Loop { wait: None }
-            wait: None,
-        }
     }
 }
 

src/asset/mod.rs

@@ -23,7 +23,10 @@ impl<T> Handle<T> {
         }
     }
 
-    pub fn from_untyped(untyped_handle: HandleUntyped) -> Option<Handle<T>> where T: 'static {
+    pub fn from_untyped(untyped_handle: HandleUntyped) -> Option<Handle<T>>
+    where
+        T: 'static,
+    {
         if TypeId::of::<T>() == untyped_handle.type_id {
             Some(Handle::new(untyped_handle.id))
         } else {
@@ -96,7 +99,8 @@ where
     T: 'static,
 {
     fn from(handle: HandleUntyped) -> Self {
-        Handle::from_untyped(handle).expect("attempted to convert untyped handle to incorrect typed handle")
+        Handle::from_untyped(handle)
+            .expect("attempted to convert untyped handle to incorrect typed handle")
     }
 }
 

src/core/core_plugin.rs

@@ -1,6 +1,6 @@
+use super::Time;
 use crate::app::{plugin::AppPlugin, AppBuilder};
 use bevy_transform::transform_system_bundle;
-use super::Time;
 
 #[derive(Default)]
 pub struct CorePlugin;
@@ -11,8 +11,7 @@ impl AppPlugin for CorePlugin {
             app = app.add_system(transform_system);
         }
 
-        app
+        app.add_resource(Time::new())
-            .add_resource(Time::new())
     }
 
     fn name(&self) -> &'static str {

src/core/mod.rs

@@ -1,9 +1,9 @@
 pub mod bytes;
-mod time;
 mod core_plugin;
 pub mod event;
+mod time;
 
 pub use bytes::*;
-pub use time::*;
 pub use core_plugin::*;
 pub use event::*;
+pub use time::*;

src/diagnostic/diagnostic_plugin.rs

@@ -2,7 +2,7 @@ use super::{
     diagnostics::{frame_time_diagnostic_system, print_diagnostics_system},
     Diagnostics,
 };
-use crate::{app::AppBuilder, app::plugin::AppPlugin};
+use crate::app::{plugin::AppPlugin, AppBuilder};
 use std::time::Duration;
 
 pub struct DiagnosticsPlugin {

src/diagnostic/mod.rs

@@ -1,5 +1,5 @@
-pub mod diagnostics;
 mod diagnostic_plugin;
+pub mod diagnostics;
 pub use diagnostic_plugin::*;
 
 use std::{
@@ -36,10 +36,8 @@ impl Diagnostic {
         }
 
         self.sum += value;
-        self.history.push_front(DiagnosticMeasurement {
+        self.history
-            time,
+            .push_front(DiagnosticMeasurement { time, value });
-            value,
-        });
     }
 
     pub fn new(id: DiagnosticId, name: &str, max_history_length: usize) -> Diagnostic {
@@ -74,22 +72,21 @@ impl Diagnostic {
 
     pub fn duration(&self) -> Option<Duration> {
         if self.history.len() < 2 {
-            return None
+            return None;
         }
 
         if let Some(oldest) = self.history.back() {
             if let Some(newest) = self.history.front() {
-                return newest.time.duration_since(oldest.time).ok()
+                return newest.time.duration_since(oldest.time).ok();
             }
         }
 
-        return None
+        return None;
     }
 
     pub fn get_max_history_length(&self) -> usize {
         self.max_history_length
     }
-
 }
 
 #[derive(Default)]
@@ -111,7 +108,9 @@ impl Diagnostics {
     }
 
     pub fn get_measurement(&self, id: DiagnosticId) -> Option<&DiagnosticMeasurement> {
-        self.diagnostics.get(&id).and_then(|diagnostic| diagnostic.history.front())
+        self.diagnostics
+            .get(&id)
+            .and_then(|diagnostic| diagnostic.history.front())
     }
 
     pub fn add_measurement(&mut self, id: DiagnosticId, value: f64) {

src/prelude.rs

@@ -1,8 +1,7 @@
 pub use crate::{
     app::{plugin::AppPlugin, App, AppBuilder},
     asset::{Asset, AssetStorage, Handle},
-    window::{Window, Windows, WindowDescriptor, WindowPlugin},
+    core::{EventReader, Events, GetEventReader, Time},
-    core::{Events, EventReader, GetEventReader, Time},
     diagnostic::DiagnosticsPlugin,
     ecs,
     ecs::{
@@ -21,6 +20,7 @@ pub use crate::{
         ActiveCamera, ActiveCamera2d, Camera, CameraType, Color, ColorSource, Light, Renderable,
     },
     ui::{Anchors, Margins, Node},
+    window::{Window, WindowDescriptor, WindowPlugin, Windows},
 };
 pub use bevy_derive::*;
 pub use bevy_transform::prelude::*;

src/render/draw_target/draw_targets/assigned_batches_draw_target.rs

@@ -76,24 +76,33 @@ impl DrawTarget for AssignedBatchesDrawTarget {
         let mut global_render_resource_assignments =
             resources.get_mut::<RenderResourceAssignments>().unwrap();
 
-        log::debug!("setting up batch bind groups for pipeline: {:?}", pipeline_handle);
+        log::debug!(
+            "setting up batch bind groups for pipeline: {:?}",
+            pipeline_handle
+        );
         log::trace!("setting up global bind groups");
         renderer.setup_bind_groups(&mut global_render_resource_assignments, pipeline_descriptor);
 
         for batch in asset_batches.get_batches_mut() {
-            log::debug!("setting up batch bind groups: {:?}", batch.render_resource_assignments.id);
+            log::debug!(
-            log::trace!("{:#?}", batch);
+                "setting up batch bind groups: {:?}",
-            renderer.setup_bind_groups(
+                batch.render_resource_assignments.id
-                &mut batch.render_resource_assignments,
-                pipeline_descriptor,
             );
+            log::trace!("{:#?}", batch);
+            renderer.setup_bind_groups(&mut batch.render_resource_assignments, pipeline_descriptor);
             for batched_entity in batch.entities.iter() {
-                let mut renderable = world.get_component_mut::<Renderable>(*batched_entity).unwrap();
+                let mut renderable = world
+                    .get_component_mut::<Renderable>(*batched_entity)
+                    .unwrap();
                 if !renderable.is_visible || renderable.is_instanced {
                     continue;
                 }
 
-                log::trace!("setting up entity bind group {:?} for batch {:?}", batched_entity, batch.render_resource_assignments.id);
+                log::trace!(
+                    "setting up entity bind group {:?} for batch {:?}",
+                    batched_entity,
+                    batch.render_resource_assignments.id
+                );
                 renderer.setup_bind_groups(
                     &mut renderable.render_resource_assignments,
                     pipeline_descriptor,

src/render/mesh.rs

@@ -2,12 +2,8 @@ use crate::{asset::Asset, math::*, render::Vertex};
 
 pub enum MeshType {
     Cube,
-    Plane {
+    Plane { size: f32 },
-        size: f32,
+    Quad { size: Vec2 },
-    },
-    Quad {
-        size: Vec2,
-    },
 }
 
 pub struct Mesh {
@@ -20,9 +16,7 @@ impl Asset<MeshType> for Mesh {
         let (vertices, indices) = match descriptor {
             MeshType::Cube => create_cube(),
             MeshType::Plane { size } => create_plane(size),
-            MeshType::Quad {
+            MeshType::Quad { size } => create_quad(size),
-                size
-            } => create_quad(size),
         };
 
         Mesh { vertices, indices }

src/render/mod.rs

@@ -1,8 +1,8 @@
 mod camera;
 pub mod mesh;
 pub mod render_graph;
-pub mod shader;
 mod render_plugin;
+pub mod shader;
 
 mod color;
 mod light;
@@ -11,8 +11,8 @@ mod vertex;
 pub use camera::*;
 pub use color::*;
 pub use light::*;
-pub use renderable::*;
 pub use render_plugin::*;
+pub use renderable::*;
 
 pub use vertex::Vertex;
 

src/render/pipeline/binding.rs

@@ -1,5 +1,5 @@
 use super::UniformProperty;
-use crate::render::texture::{TextureComponentType, TextureViewDimension, TextureFormat};
+use crate::render::texture::{TextureComponentType, TextureFormat, TextureViewDimension};
 
 #[derive(Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct BindingDescriptor {

src/render/pipeline/pipeline_compiler.rs

@@ -236,7 +236,11 @@ impl ShaderPipelineAssignments {
 }
 
 // TODO: make this a system
-pub fn update_shader_assignments(world: &mut World, resources: &mut Resources, renderer: &dyn Renderer) {
+pub fn update_shader_assignments(
+    world: &mut World,
+    resources: &mut Resources,
+    renderer: &dyn Renderer,
+) {
     // PERF: this seems like a lot of work for things that don't change that often.
     // lots of string + hashset allocations. sees uniform_resource_provider for more context
     {

src/render/render_resource/batching/asset_batcher.rs

@@ -251,10 +251,9 @@ mod tests {
         ];
         expected_batches.sort_by(|a, b| a.0.cmp(&b.0));
         // copy ignored fields
-        batches
+        batches.iter().zip(expected_batches.iter_mut()).for_each(
-            .iter()
+            |((_, ref actual), (_, ref mut expected))| copy_ignored_fields(actual, expected),
-            .zip(expected_batches.iter_mut())
+        );
-            .for_each(|((_, ref actual), (_, ref mut expected))| copy_ignored_fields(actual, expected));
         assert_eq!(
             batches,
             expected_batches

src/render/render_resource/batching/batch.rs

@@ -27,7 +27,10 @@ impl Batch {
         }
     }
 
-    pub fn get_handle<T>(&self) -> Option<Handle<T>> where T: 'static {
+    pub fn get_handle<T>(&self) -> Option<Handle<T>>
+    where
+        T: 'static,
+    {
         self.handles
             .iter()
             .map(|h| Handle::from_untyped(*h))

src/render/render_resource/resource_providers/camera2d_resource_provider.rs

@@ -1,5 +1,4 @@
 use crate::{
-    window::WindowResized,
     prelude::*,
     render::{
         render_resource::{
@@ -7,6 +6,7 @@ use crate::{
         },
         renderer::Renderer,
     },
+    window::WindowResized,
 };
 use zerocopy::AsBytes;
 

src/render/render_resource/resource_providers/camera_resource_provider.rs

@@ -1,5 +1,4 @@
 use crate::{
-    window::WindowResized,
     prelude::*,
     render::{
         render_resource::{
@@ -9,6 +8,7 @@ use crate::{
         renderer::Renderer,
         ActiveCamera, Camera,
     },
+    window::WindowResized,
 };
 use zerocopy::AsBytes;
 

src/render/render_resource/resource_providers/frame_texture_resource_provider.rs

@@ -1,11 +1,11 @@
 use crate::{
-    window::Windows,
     prelude::World,
     render::{
         render_resource::{RenderResourceAssignments, ResourceProvider},
         renderer::Renderer,
         texture::TextureDescriptor,
     },
+    window::Windows,
 };
 use legion::prelude::Resources;
 

src/render/render_resource/resource_providers/mesh_resource_provider.rs

@@ -42,12 +42,22 @@ impl MeshResourceProvider {
         }
     }
 
-    fn setup_mesh_resources(renderer: &mut dyn Renderer, mesh_storage: &mut AssetStorage<Mesh>, handle: Handle<Mesh>, render_resource_assignments: &mut RenderResourceAssignments) {
+    fn setup_mesh_resources(
+        renderer: &mut dyn Renderer,
+        mesh_storage: &mut AssetStorage<Mesh>,
+        handle: Handle<Mesh>,
+        render_resource_assignments: &mut RenderResourceAssignments,
+    ) {
         let (vertex_buffer, index_buffer) = if let Some(vertex_buffer) = renderer
             .get_render_resources()
             .get_mesh_vertices_resource(handle)
         {
-            (vertex_buffer, renderer.get_render_resources().get_mesh_indices_resource(handle))
+            (
+                vertex_buffer,
+                renderer
+                    .get_render_resources()
+                    .get_mesh_indices_resource(handle),
+            )
         } else {
             let mesh_asset = mesh_storage.get(&handle).unwrap();
             let vertex_buffer = renderer.create_buffer_with_data(
@@ -109,7 +119,12 @@ impl ResourceProvider for MeshResourceProvider {
                 for batch in batches {
                     let handle = batch.get_handle::<Mesh>().unwrap();
                     log::trace!("setup mesh for {:?}", batch.render_resource_assignments.id);
-                    Self::setup_mesh_resources(renderer, &mut mesh_storage, handle, &mut batch.render_resource_assignments);
+                    Self::setup_mesh_resources(
+                        renderer,
+                        &mut mesh_storage,
+                        handle,
+                        &mut batch.render_resource_assignments,
+                    );
                 }
             }
         };

src/render/renderer/renderers/wgpu_renderer/mod.rs

@@ -10,7 +10,8 @@ pub use wgpu_resources::*;
 use crate::{
     app::{plugin::AppPlugin, system_stage, AppBuilder},
     core::Events,
-    render::renderer::Renderer, window::{WindowCreated, WindowResized},
+    render::renderer::Renderer,
+    window::{WindowCreated, WindowResized},
 };
 
 use legion::prelude::*;

src/ui/mod.rs

@@ -15,8 +15,7 @@ pub struct UiPlugin;
 
 impl AppPlugin for UiPlugin {
     fn build(&self, app: AppBuilder) -> AppBuilder {
-        app
+        app.add_system(ui_update_system())
-            .add_system(ui_update_system())
     }
     fn name(&self) -> &'static str {
         "UI"

src/window/mod.rs

@@ -1,12 +1,12 @@
+mod events;
+mod window_plugin;
+mod windows;
 #[cfg(feature = "winit")]
 pub mod winit;
-mod events;
-mod windows;
-mod window_plugin;
 
 pub use events::*;
-pub use windows::*;
 pub use window_plugin::*;
+pub use windows::*;
 
 use uuid::Uuid;
 

src/window/window_plugin.rs

@@ -1,5 +1,8 @@
-use super::{CreateWindow, WindowCreated, WindowResized, Windows, WindowDescriptor};
+use super::{CreateWindow, WindowCreated, WindowDescriptor, WindowResized, Windows};
-use crate::{core::Events, app::{plugin::AppPlugin, AppBuilder}};
+use crate::{
+    app::{plugin::AppPlugin, AppBuilder},
+    core::Events,
+};
 
 pub struct WindowPlugin {
     pub primary_window: Option<WindowDescriptor>,
@@ -15,7 +18,8 @@ impl Default for WindowPlugin {
 
 impl AppPlugin for WindowPlugin {
     fn build(&self, mut app: AppBuilder) -> AppBuilder {
-        app = app.add_event::<WindowResized>()
+        app = app
+            .add_event::<WindowResized>()
             .add_event::<CreateWindow>()
             .add_event::<WindowCreated>()
             .add_resource(Windows::default());

src/window/winit/mod.rs

@@ -109,7 +109,13 @@ fn handle_create_window_events(
         winit_windows.create_window(event_loop, &window);
         let window_id = window.id;
         windows.add(window);
-        let is_primary = windows.get_primary().map(|primary| primary.id == window_id).unwrap_or(false);
+        let is_primary = windows
-        window_created_events.send(WindowCreated { id: window_id, is_primary });
+            .get_primary()
+            .map(|primary| primary.id == window_id)
+            .unwrap_or(false);
+        window_created_events.send(WindowCreated {
+            id: window_id,
+            is_primary,
+        });
     }
 }

src/window/winit/winit_windows.rs

@@ -1,4 +1,4 @@
-use crate::{window::WindowId, prelude::*};
+use crate::{prelude::*, window::WindowId};
 use std::collections::HashMap;
 
 #[derive(Default)]