cargo fmt

bevy_app/src/app_builder.rs

@@ -1,8 +1,7 @@
 use crate::{
-    stage,
     plugin::{load_plugin, AppPlugin},
     schedule_plan::SchedulePlan,
-    App, Events,
+    stage, App, Events,
 };
 
 use legion::prelude::{Resources, Runnable, Schedulable, Universe, World};
@@ -188,10 +187,7 @@ impl AppBuilder {
         T: Send + Sync + 'static,
     {
         self.add_resource(Events::<T>::default())
-            .add_system_to_stage(
+            .add_system_to_stage(stage::EVENT_UPDATE, Events::<T>::build_update_system())
-                stage::EVENT_UPDATE,
-                Events::<T>::build_update_system(),
-            )
     }
 
     pub fn add_resource<T>(&mut self, resource: T) -> &mut Self

bevy_app/src/event.rs

@@ -1,4 +1,4 @@
-use legion::prelude::{Schedulable, SystemBuilder, Resources};
+use legion::prelude::{Resources, Schedulable, SystemBuilder};
 use std::marker::PhantomData;
 
 struct EventInstance<T> {

bevy_core/src/time.rs

@@ -45,4 +45,3 @@ pub fn stop_timer_system() -> Box<dyn Schedulable> {
             time.stop();
         })
 }
-

bevy_derive/src/lib.rs

@@ -77,7 +77,8 @@ impl Default for ModuleAttributeArgs {
 static MODULE_ATTRIBUTE_NAME: &'static str = "module";
 
 fn get_modules(ast: &DeriveInput) -> Modules {
-    let module_attribute_args =    ast.attrs
+    let module_attribute_args = ast
+        .attrs
         .iter()
         .find(|a| a.path.get_ident().as_ref().unwrap().to_string() == MODULE_ATTRIBUTE_NAME)
         .map(|a| {

bevy_diagnostic/src/lib.rs

@@ -2,9 +2,9 @@ mod diagnostic;
 pub mod diagnostics;
 pub use diagnostic::*;
 
-use bevy_app::{AppPlugin, AppBuilder};
+use bevy_app::{AppBuilder, AppPlugin};
+use diagnostics::{frame_time_diagnostic_system, print_diagnostics_system};
 use std::time::Duration;
-use diagnostics::{print_diagnostics_system, frame_time_diagnostic_system};
 
 pub struct DiagnosticsPlugin {
     pub print_wait_duration: Duration,

bevy_legion/legion_core/src/borrow.rs

@@ -1,9 +1,9 @@
 //! Atomic runtime borrow checking module.
 //! These types implement something akin to `RefCell`, but are atomically handled allowing them to
 //! cross thread boundaries.
+use std::any::{type_name, Any};
 use std::cell::UnsafeCell;
 use std::hash::{Hash, Hasher};
-use std::any::{Any, type_name};
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::sync::atomic::AtomicIsize;
@@ -17,9 +17,7 @@ pub trait DowncastTypename {
     fn is_typename<T: Any>(&self) -> bool;
 }
 
-pub fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str {
+pub fn type_name_of_val<T: ?Sized>(_val: &T) -> &'static str { type_name::<T>() }
-    type_name::<T>()
-}
 /// A `RefCell` implementation which is thread safe. This type performs all the standard runtime
 /// borrow checking which would be familiar from using `RefCell`.
 ///

bevy_legion/legion_systems/src/resource.rs

@@ -1,10 +1,10 @@
-use legion_core::borrow::DowncastTypename;
 use downcast_rs::{impl_downcast, Downcast};
 use fxhash::FxHashMap;
+use legion_core::borrow::DowncastTypename;
 use legion_core::borrow::{AtomicRefCell, Ref, RefMut};
 use legion_core::query::{Read, ReadOnly, Write};
 use std::{
-    any::{Any, type_name},
+    any::{type_name, Any},
     marker::PhantomData,
     ops::{Deref, DerefMut},
 };

bevy_render/src/entity.rs

@@ -1,7 +1,10 @@
-use bevy_derive::EntityArchetype;
+use crate::{
+    mesh::Mesh, shader::uniforms::StandardMaterial, ActiveCamera, ActiveCamera2d, Camera,
+    CameraType, Light, Renderable,
+};
 use bevy_asset::Handle;
-use crate::{shader::uniforms::StandardMaterial, mesh::Mesh, Renderable, Light, Camera, ActiveCamera, ActiveCamera2d, CameraType};
+use bevy_derive::EntityArchetype;
-use bevy_transform::components::{Translation, LocalToWorld, Rotation, Scale};
+use bevy_transform::components::{LocalToWorld, Rotation, Scale, Translation};
 
 #[derive(EntityArchetype, Default)]
 #[module(meta = false)]

bevy_render/src/lib.rs

@@ -1,9 +1,9 @@
 #![feature(min_specialization)]
 mod camera;
+pub mod entity;
 pub mod mesh;
 pub mod render_graph;
 pub mod shader;
-pub mod entity;
 
 mod color;
 mod light;
@@ -30,14 +30,12 @@ use self::{
     draw_target::draw_targets::{
         AssignedBatchesDrawTarget, AssignedMeshesDrawTarget, MeshesDrawTarget, UiDrawTarget,
     },
+    mesh::Mesh,
     pass::passes::ForwardPassBuilder,
     pipeline::{
-        pipelines::ForwardPipelineBuilder, PipelineCompiler, ShaderPipelineAssignments,
+        pipelines::ForwardPipelineBuilder, PipelineCompiler, PipelineDescriptor,
-        VertexBufferDescriptors, PipelineDescriptor
+        ShaderPipelineAssignments, VertexBufferDescriptors,
     },
-    shader::{Shader, uniforms::StandardMaterial},
-    texture::Texture,
-    mesh::Mesh,
     render_graph::RenderGraph,
     render_resource::{
         build_entity_render_resource_assignments_system,
@@ -47,11 +45,13 @@ use self::{
         },
         AssetBatchers, EntityRenderResourceAssignments, RenderResourceAssignments,
     },
+    shader::{uniforms::StandardMaterial, Shader},
+    texture::Texture,
 };
 
-use bevy_app::{AppBuilder, AppPlugin, GetEventReader, stage};
+use bevy_app::{stage, AppBuilder, AppPlugin, GetEventReader};
-use bevy_transform::prelude::LocalToWorld;
 use bevy_asset::AssetStorage;
+use bevy_transform::prelude::LocalToWorld;
 use bevy_window::WindowResized;
 
 pub static RENDER_STAGE: &str = "render";
@@ -95,8 +95,7 @@ impl AppPlugin for RenderPlugin {
     fn build(&self, app: &mut AppBuilder) {
         let mut asset_batchers = AssetBatchers::default();
         asset_batchers.batch_types2::<Mesh, StandardMaterial>();
-        app
+        app.add_system(build_entity_render_resource_assignments_system())
-            .add_system(build_entity_render_resource_assignments_system())
             .add_stage_after(stage::UPDATE, RENDER_STAGE)
             .add_resource(RenderGraph::default())
             .add_resource(AssetStorage::<Mesh>::new())

bevy_render/src/light.rs

@@ -1,8 +1,8 @@
 use super::{Color, PerspectiveCamera};
+use bevy_transform::components::Translation;
+use glam::Mat4;
 use std::ops::Range;
 use zerocopy::{AsBytes, FromBytes};
-use glam::Mat4;
-use bevy_transform::components::Translation;
 
 pub struct Light {
     pub color: Color,

bevy_render/src/mesh.rs

@@ -1,4 +1,4 @@
-use crate::{Vertex};
+use crate::Vertex;
 use bevy_asset::Asset;
 use glam::*;
 

bevy_render/src/pipeline/pipeline_compiler.rs

@@ -1,13 +1,15 @@
-use super::{BindType, PipelineDescriptor, PipelineLayout, PipelineLayoutType, VertexBufferDescriptors};
+use super::{
-use bevy_asset::{AssetStorage, Handle};
+    BindType, PipelineDescriptor, PipelineLayout, PipelineLayoutType, VertexBufferDescriptors,
+};
 use crate::{
     render_resource::{
         BufferInfo, RenderResourceAssignments, RenderResourceAssignmentsId, ResourceInfo,
     },
     renderer::Renderer,
-    Renderable,
     shader::{Shader, ShaderSource},
+    Renderable,
 };
+use bevy_asset::{AssetStorage, Handle};
 use std::collections::{HashMap, HashSet};
 
 use legion::prelude::*;

bevy_render/src/render_graph/render_graph.rs

@@ -1,14 +1,12 @@
 use super::RenderGraphBuilder;
 use crate::{
-    {
     draw_target::DrawTarget,
     pass::PassDescriptor,
     pipeline::{PipelineCompiler, PipelineDescriptor},
     render_resource::ResourceProvider,
     renderer::Renderer,
-        texture::TextureDescriptor,
     shader::Shader,
-    },
+    texture::TextureDescriptor,
 };
 use bevy_asset::{AssetStorage, Handle};
 use legion::prelude::*;

bevy_render/src/render_graph/render_graph_builder.rs

@@ -1,13 +1,11 @@
 use super::RenderGraph;
 use crate::{
-    {
     draw_target::DrawTarget,
     pass::PassDescriptor,
     pipeline::{PipelineBuilder, PipelineDescriptor},
     render_resource::ResourceProvider,
-        texture::TextureDescriptor,
     shader::Shader,
-    },
+    texture::TextureDescriptor,
 };
 
 use bevy_asset::AssetStorage;

bevy_render/src/render_resource/batching/batch.rs

@@ -1,5 +1,5 @@
-use bevy_asset::{Handle, HandleUntyped};
 use crate::render_resource::RenderResourceAssignments;
+use bevy_asset::{Handle, HandleUntyped};
 use legion::prelude::Entity;
 use std::collections::{HashMap, HashSet};
 

bevy_render/src/render_resource/render_resource.rs

@@ -1,5 +1,5 @@
-use bevy_asset::Handle;
 use crate::{mesh::Mesh, texture::Texture};
+use bevy_asset::Handle;
 use std::collections::HashMap;
 
 #[derive(Copy, Clone, Hash, Debug, Eq, PartialEq)]

bevy_render/src/render_resource/resource_providers/camera_resource_provider.rs

@@ -9,9 +9,9 @@ use crate::{
     ActiveCamera, Camera,
 };
 
-use bevy_app::{Events, EventReader};
+use bevy_app::{EventReader, Events};
-use legion::prelude::*;
 use bevy_transform::prelude::*;
+use legion::prelude::*;
 use zerocopy::AsBytes;
 
 pub struct CameraResourceProvider {

bevy_render/src/render_resource/resource_providers/frame_texture_resource_provider.rs

@@ -1,9 +1,9 @@
-use bevy_window::Windows;
 use crate::{
     render_resource::{RenderResourceAssignments, ResourceProvider},
     renderer::Renderer,
     texture::TextureDescriptor,
 };
+use bevy_window::Windows;
 use legion::prelude::*;
 
 pub struct FrameTextureResourceProvider {

bevy_render/src/render_resource/resource_providers/mesh_resource_provider.rs

@@ -6,8 +6,7 @@ use crate::{
     },
     renderer::Renderer,
     shader::AsUniforms,
-    Renderable,
+    Renderable, Vertex,
-    Vertex,
 };
 use bevy_asset::{AssetStorage, Handle};
 use legion::{filter::*, prelude::*};

bevy_render/src/renderer.rs

@@ -1,5 +1,3 @@
-use bevy_asset::{AssetStorage, Handle};
-use legion::prelude::*;
 use crate::{
     pipeline::PipelineDescriptor,
     render_resource::{
@@ -8,6 +6,8 @@ use crate::{
     shader::Shader,
     texture::{SamplerDescriptor, TextureDescriptor},
 };
+use bevy_asset::{AssetStorage, Handle};
+use legion::prelude::*;
 use std::ops::Range;
 
 pub trait Renderer {

bevy_render/src/texture/texture.rs

@@ -1,6 +1,6 @@
+use crate::shader::ShaderDefSuffixProvider;
 use bevy_asset::{Asset, Handle};
 use std::fs::File;
-use crate::shader::ShaderDefSuffixProvider;
 
 pub enum TextureType {
     Data(Vec<u8>, usize, usize),

bevy_render/src/vertex.rs

@@ -1,9 +1,9 @@
 use std::convert::From;
 use zerocopy::{AsBytes, FromBytes};
 
-use bevy_derive::Uniforms;
-use bevy_core;
 use bevy_asset;
+use bevy_core;
+use bevy_derive::Uniforms;
 
 #[repr(C)]
 #[derive(Clone, Copy, AsBytes, FromBytes, Uniforms)]

bevy_transform/src/components/non_uniform_scale.rs

@@ -33,10 +33,6 @@ impl From<&mut Vec3> for NonUniformScale {
 impl fmt::Display for NonUniformScale {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let (x, y, z) = self.0.into();
-        write!(
+        write!(f, "NonUniformScale({}, {}, {})", x, y, z)
-            f,
-            "NonUniformScale({}, {}, {})",
-            x, y, z
-        )
     }
 }

bevy_transform/src/hierarchy_maintenance_system.rs

@@ -6,9 +6,7 @@ use std::collections::HashMap;
 pub fn build(_: &mut World) -> Vec<Box<dyn Schedulable>> {
     let missing_previous_parent_system = SystemBuilder::<()>::new("MissingPreviousParentSystem")
         // Entities with missing `PreviousParent`
-        .with_query(<Read<Parent>>::query().filter(
+        .with_query(<Read<Parent>>::query().filter(!component::<PreviousParent>()))
-            !component::<PreviousParent>(),
-        ))
         .build(move |commands, world, _resource, query| {
             // Add missing `PreviousParent` components
             for (entity, _parent) in query.iter_entities(world) {
@@ -21,9 +19,7 @@ pub fn build(_: &mut World) -> Vec<Box<dyn Schedulable>> {
         // Entities with a removed `Parent`
         .with_query(<Read<PreviousParent>>::query().filter(!component::<Parent>()))
         // Entities with a changed `Parent`
-        .with_query(<(Read<Parent>, Write<PreviousParent>)>::query().filter(
+        .with_query(<(Read<Parent>, Write<PreviousParent>)>::query().filter(changed::<Parent>()))
-            changed::<Parent>(),
-        ))
         // Deleted Parents (ie Entities with `Children` and without a `LocalToWorld`).
         .write_component::<Children>()
         .build(move |commands, world, _resource, queries| {

bevy_transform/src/lib.rs

@@ -1,5 +1,5 @@
-pub use legion as ecs;
 pub use glam as math;
+pub use legion as ecs;
 
 pub mod components;
 pub mod hierarchy_maintenance_system;
@@ -9,10 +9,8 @@ pub mod local_to_world_system;
 pub mod transform_system_bundle;
 
 pub mod prelude {
-    pub use crate::components::*;
+    pub use crate::{
-    pub use crate::hierarchy_maintenance_system;
+        components::*, hierarchy_maintenance_system, local_to_parent_system,
-    pub use crate::local_to_parent_system;
+        local_to_world_propagate_system, local_to_world_system, transform_system_bundle,
-    pub use crate::local_to_world_propagate_system;
+    };
-    pub use crate::local_to_world_system;
-    pub use crate::transform_system_bundle;
 }

bevy_transform/src/local_to_parent_system.rs

@@ -1,5 +1,9 @@
 #![allow(dead_code)]
-use crate::{components::*, ecs::prelude::*, math::{Mat4, Vec3, Quat}};
+use crate::{
+    components::*,
+    ecs::prelude::*,
+    math::{Mat4, Quat, Vec3},
+};
 
 pub fn build(_: &mut World) -> Box<dyn Schedulable> {
     SystemBuilder::<()>::new("LocalToParentUpdateSystem")
@@ -126,7 +130,8 @@ pub fn build(_: &mut World) -> Box<dyn Schedulable> {
                 s.spawn(|_| unsafe {
                     // Scale
                     c.for_each_unchecked(world, |(mut ltw, scale)| {
-                        *ltw = LocalToParent(Mat4::from_scale(Vec3::new(scale.0, scale.0, scale.0)));
+                        *ltw =
+                            LocalToParent(Mat4::from_scale(Vec3::new(scale.0, scale.0, scale.0)));
                     });
                 });
                 s.spawn(|_| unsafe {
@@ -137,9 +142,10 @@ pub fn build(_: &mut World) -> Box<dyn Schedulable> {
 
                     // Translation + Rotation
                     e.for_each_unchecked(world, |(mut ltw, translation, rotation)| {
-                        *ltw = LocalToParent(
+                        *ltw = LocalToParent(Mat4::from_rotation_translation(
-                            Mat4::from_rotation_translation(rotation.0, translation.0)
+                            rotation.0,
-                        );
+                            translation.0,
+                        ));
                     });
                 });
                 s.spawn(|_| unsafe {
@@ -282,63 +288,42 @@ mod test {
                 .get_component::<LocalToParent>(translation_and_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), Quat::default(), t.0)
-                Vec3::new(s.0, s.0, s.0),
-                Quat::default(),
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToParent>(translation_and_nus)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(nus.0, Quat::default(), t.0)
-                nus.0,
-                Quat::default(),
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToParent>(rotation_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), r.0, Vec3::default())
-                Vec3::new(s.0, s.0, s.0),
-                r.0,
-                Vec3::default()
-            )
         );
         assert_eq!(
-            world.get_component::<LocalToParent>(rotation_nus).unwrap().0,
+            world
-            Mat4::from_scale_rotation_translation(
+                .get_component::<LocalToParent>(rotation_nus)
-                nus.0,
+                .unwrap()
-                r.0,
+                .0,
-                Vec3::default()
+            Mat4::from_scale_rotation_translation(nus.0, r.0, Vec3::default())
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToParent>(translation_rotation_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), r.0, t.0)
-                Vec3::new(s.0, s.0, s.0),
-                r.0,
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToParent>(translation_rotation_nus)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(nus.0, r.0, t.0)
-                nus.0,
-                r.0,
-                t.0
-            )
         );
     }
 }

bevy_transform/src/local_to_world_propagate_system.rs

@@ -1,5 +1,8 @@
 #![allow(dead_code)]
-use crate::{components::*, ecs::{prelude::*, systems::SubWorld}};
+use crate::{
+    components::*,
+    ecs::{prelude::*, systems::SubWorld},
+};
 
 pub fn build(_: &mut World) -> Box<dyn Schedulable> {
     SystemBuilder::<()>::new("LocalToWorldPropagateSystem")

bevy_transform/src/local_to_world_system.rs

@@ -1,5 +1,9 @@
 #![allow(dead_code)]
-use crate::{components::*, ecs::prelude::*, math::{Mat4, Vec3, Quat}};
+use crate::{
+    components::*,
+    ecs::prelude::*,
+    math::{Mat4, Quat, Vec3},
+};
 
 pub fn build(_: &mut World) -> Box<dyn Schedulable> {
     SystemBuilder::<()>::new("LocalToWorldUpdateSystem")
@@ -152,9 +156,10 @@ pub fn build(_: &mut World) -> Box<dyn Schedulable> {
                 s.spawn(|_| unsafe {
                     // Translation + Rotation
                     e.for_each_unchecked(world, |(mut ltw, translation, rotation)| {
-                        *ltw = LocalToWorld(
+                        *ltw = LocalToWorld(Mat4::from_rotation_translation(
-                            Mat4::from_rotation_translation(rotation.0, translation.0)
+                            rotation.0,
-                        );
+                            translation.0,
+                        ));
                     });
                 });
                 s.spawn(|_| unsafe {
@@ -304,63 +309,39 @@ mod test {
                 .get_component::<LocalToWorld>(translation_and_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), Quat::default(), t.0)
-                Vec3::new(s.0, s.0, s.0),
-                Quat::default(),
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToWorld>(translation_and_nus)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(nus.0, Quat::default(), t.0)
-                nus.0,
-                Quat::default(),
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToWorld>(rotation_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), r.0, Vec3::default())
-                Vec3::new(s.0, s.0, s.0),
-                r.0,
-                Vec3::default()
-            )
         );
         assert_eq!(
             world.get_component::<LocalToWorld>(rotation_nus).unwrap().0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(nus.0, r.0, Vec3::default())
-                nus.0,
-                r.0,
-                Vec3::default()
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToWorld>(translation_rotation_scale)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(Vec3::new(s.0, s.0, s.0), r.0, t.0)
-                Vec3::new(s.0, s.0, s.0),
-                r.0,
-                t.0
-            )
         );
         assert_eq!(
             world
                 .get_component::<LocalToWorld>(translation_rotation_nus)
                 .unwrap()
                 .0,
-            Mat4::from_scale_rotation_translation(
+            Mat4::from_scale_rotation_translation(nus.0, r.0, t.0)
-                nus.0,
-                r.0,
-                t.0
-            )
         );
     }
 }

bevy_ui/src/entity.rs

@@ -1,5 +1,5 @@
-use bevy_derive::EntityArchetype;
 use super::Node;
+use bevy_derive::EntityArchetype;
 
 #[derive(EntityArchetype)]
 #[module(meta = false)]

bevy_wgpu/src/lib.rs

@@ -7,7 +7,7 @@ pub use wgpu_render_pass::*;
 pub use wgpu_renderer::*;
 pub use wgpu_resources::*;
 
-use bevy_app::{AppPlugin, AppBuilder, Events};
+use bevy_app::{AppBuilder, AppPlugin, Events};
 use bevy_render::{renderer::Renderer, RENDER_STAGE};
 use bevy_window::{WindowCreated, WindowResized};
 use legion::prelude::*;

bevy_wgpu/src/wgpu_renderer.rs

@@ -1,4 +1,7 @@
-use super::{wgpu_type_converter::{OwnedWgpuVertexBufferDescriptor, WgpuInto}, WgpuRenderPass, WgpuResources};
+use super::{
+    wgpu_type_converter::{OwnedWgpuVertexBufferDescriptor, WgpuInto},
+    WgpuRenderPass, WgpuResources,
+};
 use bevy_app::{EventReader, Events};
 use bevy_asset::{AssetStorage, Handle};
 use bevy_render::{
@@ -201,10 +204,18 @@ impl WgpuRenderer {
             attachment,
             clear_depth: depth_stencil_attachment_descriptor.clear_depth,
             clear_stencil: depth_stencil_attachment_descriptor.clear_stencil,
-            depth_load_op: depth_stencil_attachment_descriptor.depth_load_op.wgpu_into(),
+            depth_load_op: depth_stencil_attachment_descriptor
-            depth_store_op: depth_stencil_attachment_descriptor.depth_store_op.wgpu_into(),
+                .depth_load_op
-            stencil_load_op: depth_stencil_attachment_descriptor.stencil_load_op.wgpu_into(),
+                .wgpu_into(),
-            stencil_store_op: depth_stencil_attachment_descriptor.stencil_store_op.wgpu_into(),
+            depth_store_op: depth_stencil_attachment_descriptor
+                .depth_store_op
+                .wgpu_into(),
+            stencil_load_op: depth_stencil_attachment_descriptor
+                .stencil_load_op
+                .wgpu_into(),
+            stencil_store_op: depth_stencil_attachment_descriptor
+                .stencil_store_op
+                .wgpu_into(),
         }
     }
 

bevy_wgpu/src/wgpu_resources.rs

@@ -198,8 +198,10 @@ impl WgpuResources {
         let device_rc = renderer.device.clone();
         let device = device_rc.borrow();
 
-        let mut mapped =
+        let mut mapped = device.create_buffer_mapped(
-            device.create_buffer_mapped(buffer_info.size as usize, buffer_info.buffer_usage.wgpu_into());
+            buffer_info.size as usize,
+            buffer_info.buffer_usage.wgpu_into(),
+        );
         setup_data(&mut mapped.data, renderer);
         mapped.finish()
     }

bevy_wgpu/src/wgpu_type_converter.rs

@@ -22,19 +22,19 @@ pub trait WgpuFrom<T> {
     fn from(val: T) -> Self;
 }
 
-pub trait WgpuInto<U>
+pub trait WgpuInto<U> {
-{
     fn wgpu_into(self) -> U;
 }
 
-impl<T, U> WgpuInto<U> for T where U: WgpuFrom<T>
+impl<T, U> WgpuInto<U> for T
+where
+    U: WgpuFrom<T>,
 {
     fn wgpu_into(self) -> U {
         U::from(self)
     }
 }
 
-
 impl WgpuFrom<VertexFormat> for wgpu::VertexFormat {
     fn from(val: VertexFormat) -> Self {
         match val {

bevy_window/src/lib.rs

@@ -1,14 +1,12 @@
 mod events;
 mod window;
 mod windows;
-#[cfg(feature = "winit")]
-pub mod winit;
 
 pub use events::*;
 pub use window::*;
 pub use windows::*;
 
-use bevy_app::{AppPlugin, AppBuilder, Events};
+use bevy_app::{AppBuilder, AppPlugin, Events};
 
 pub struct WindowPlugin {
     pub primary_window: Option<WindowDescriptor>,
@@ -24,14 +22,14 @@ impl Default for WindowPlugin {
 
 impl AppPlugin for WindowPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app
+        app.add_event::<WindowResized>()
-            .add_event::<WindowResized>()
             .add_event::<CreateWindow>()
             .add_event::<WindowCreated>()
             .add_resource(Windows::default());
 
         if let Some(ref primary_window_descriptor) = self.primary_window {
-            let mut create_window_event = app.resources().get_mut::<Events<CreateWindow>>().unwrap();
+            let mut create_window_event =
+                app.resources().get_mut::<Events<CreateWindow>>().unwrap();
             create_window_event.send(CreateWindow {
                 descriptor: primary_window_descriptor.clone(),
             });

bevy_winit/src/converters.rs

@@ -7,7 +7,9 @@ pub fn convert_keyboard_input(keyboard_input: &winit::event::KeyboardInput) -> K
     KeyboardInput {
         scan_code: keyboard_input.scancode,
         state: convert_element_state(keyboard_input.state),
-        virtual_key_code: keyboard_input.virtual_keycode.map(|v| convert_virtual_key_code(v)),
+        virtual_key_code: keyboard_input
+            .virtual_keycode
+            .map(|v| convert_virtual_key_code(v)),
     }
 }
 

examples/input_mouse.rs

@@ -1,4 +1,7 @@
-use bevy::{input::mouse::{MouseButtonInput, MouseMotion}, prelude::*};
+use bevy::{
+    input::mouse::{MouseButtonInput, MouseMotion},
+    prelude::*,
+};
 
 fn main() {
     App::build()
@@ -14,7 +17,10 @@ pub fn mouse_input_system(resources: &mut Resources) -> Box<dyn Schedulable> {
         .read_resource::<Events<MouseButtonInput>>()
         .read_resource::<Events<MouseMotion>>()
         .build(
-            move |_command_buffer, _world, (mouse_button_input_events, mouse_motion_events), _queries| {
+            move |_command_buffer,
+                  _world,
+                  (mouse_button_input_events, mouse_motion_events),
+                  _queries| {
                 for event in mouse_button_input_events.iter(&mut mouse_button_input_event_reader) {
                     println!("{:?}", event);
                 }

src/lib.rs

@@ -23,8 +23,7 @@ pub trait AddDefaultPlugins {
 
 impl AddDefaultPlugins for AppBuilder {
     fn add_default_plugins(&mut self) -> &mut Self {
-        self
+        self.add_plugin(bevy_core::CorePlugin::default())
-            .add_plugin(bevy_core::CorePlugin::default())
             .add_plugin(bevy_input::InputPlugin::default())
             .add_plugin(bevy_window::WindowPlugin::default())
             .add_plugin(bevy_render::RenderPlugin::default())
@@ -41,12 +40,9 @@ impl AddDefaultPlugins for AppBuilder {
 
         #[cfg(feature = "bevy_wgpu")]
         {
-            self.add_plugin(
+            self.add_plugin(bevy_wgpu::WgpuRendererPlugin::default());
-                bevy_wgpu::WgpuRendererPlugin::default(),
-            );
         }
 
         self
     }
-    
 }