Improve compile parallelism by converting bevy::prelude imports to bevy_[module] imports

Cargo.toml

@@ -18,13 +18,19 @@ required-features = ["json_loader"]
 default = ["json_loader"]
 json_loader = ["serde", "dep:serde_json"]
 toml_loader = ["serde", "dep:toml"]
-serde = ["dep:serde", "bevy/serialize"]
+serde = ["dep:serde"]
 
 [dependencies]
 serde = { version = "^1.0", optional = true }
 serde_json = { version = "^1.0", optional = true }
 toml = { version = "0.8", optional = true }
-bevy = { version = "^0.15", default-features = false, features = ["bevy_asset", "bevy_sprite"] }
+
+bevy_asset = "0.16"
+bevy_sprite = "0.16"
+bevy_ecs = "0.16"
+bevy_reflect = "0.16"
+bevy_app = "0.16"
+bevy_time = "0.16"
 
 [dev-dependencies]
-bevy = "0.15"
+bevy = "0.16"

examples/basic.rs

@@ -61,7 +61,7 @@ fn spawn_assets(mut commands: Commands, assets: Res<ExampleAssets>) {
 
 	commands.spawn((
 		Camera2d::default(),
-		OrthographicProjection {
+		Projection::Orthographic(OrthographicProjection {
 			area: Rect::new(-(WIDTH / 2.0), -(HEIGHT / 2.0), WIDTH / 2.0, HEIGHT / 2.0),
 			scaling_mode: ScalingMode::AutoMin {
 				min_height: HEIGHT,
@@ -70,7 +70,7 @@ fn spawn_assets(mut commands: Commands, assets: Res<ExampleAssets>) {
 			far: 1000.,
 			near: -1000.,
 			..OrthographicProjection::default_2d()
-		},
+		}),
 	));
 }
 

src/definitions.rs

+use crate::directionality::Directionality;
+use bevy_asset::{Asset, Handle};
+use bevy_ecs::bundle::Bundle;
+use bevy_ecs::component::Component;
+use bevy_reflect::{Reflect, TypePath};
+use bevy_sprite::Sprite;
 use std::collections::HashMap;
 use std::time::Duration;
+macro_rules! dr {
+	($type: ident -> $output: ty) => {
+		impl ::std::ops::Deref for $type {
+			type Target = $output;
+			fn deref(&self) -> &Self::Target {
+				&self.0
+			}
+		}
 
-use bevy::prelude::*;
-use bevy::reflect::TypePath;
-
-use crate::directionality::Directionality;
+		impl ::std::ops::DerefMut for $type {
+			fn deref_mut(&mut self) -> &mut Self::Target {
+				&mut self.0
+			}
+		}
+	};
+}
 
 #[derive(Clone, PartialOrd, PartialEq, Debug, Default, Reflect)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -19,16 +36,18 @@ impl AnimationFrames {
 	}
 }
 
-#[derive(Clone, Debug, TypePath, PartialEq, Default, Deref, DerefMut, Asset)]
+#[derive(Clone, Debug, TypePath, PartialEq, Default, Asset)]
 #[cfg_attr(
 	feature = "serde",
 	derive(serde::Serialize, serde::Deserialize),
 	serde(transparent)
 )]
 pub struct AnimationSet(pub HashMap<String, AnimationFrames>);
+dr!(AnimationSet -> HashMap<String, AnimationFrames>);
 
-#[derive(Clone, Debug, Component, PartialEq, Default, Deref, DerefMut)]
+#[derive(Clone, Debug, Component, PartialEq, Default)]
 pub struct AnimationHandle(pub Handle<AnimationSet>);
+dr!(AnimationHandle -> Handle<AnimationSet>);
 
 #[derive(Copy, Clone, Debug, Component, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -154,7 +173,7 @@ pub fn create_child_animation() -> impl Bundle {
 	(ChildAnimation,)
 }
 
-#[derive(Clone, Debug, Component, PartialEq, PartialOrd, Default, Deref, DerefMut)]
+#[derive(Clone, Debug, Component, PartialEq, PartialOrd, Default)]
 #[cfg_attr(
 	feature = "serde",
 	derive(serde::Serialize, serde::Deserialize),
@@ -162,6 +181,8 @@ pub fn create_child_animation() -> impl Bundle {
 )]
 #[require(SimpleAnimationStatus)]
 pub struct SimpleAnimation(pub AnimationFrames);
+dr!(SimpleAnimation -> AnimationFrames);
+
 impl From<AnimationFrames> for SimpleAnimation {
 	fn from(value: AnimationFrames) -> Self {
 		SimpleAnimation(value)
@@ -181,11 +202,12 @@ impl SimpleAnimation {
 	}
 }
 
-#[derive(Clone, Debug, Component, PartialEq, Eq, Default, Deref, DerefMut)]
+#[derive(Clone, Debug, Component, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct OverrideData(pub u128);
+dr!(OverrideData -> u128);
 
-#[derive(Clone, Debug, Component, PartialEq, Default, Deref, DerefMut)]
+#[derive(Clone, Debug, Component, PartialEq, Default)]
 #[cfg_attr(
 	feature = "serde",
 	derive(serde::Serialize, serde::Deserialize),
@@ -193,6 +215,7 @@ pub struct OverrideData(pub u128);
 )]
 #[require(OverrideData)]
 pub struct AnimationOverride(pub AnimationStatus);
+dr!(AnimationOverride -> AnimationStatus);
 
 impl AnimationOverride {
 	pub fn new(name: impl ToString) -> Self {

src/directionality.rs

-use bevy::prelude::Component;
+use bevy_ecs::component::Component;
 use std::fmt::{Display, Formatter};
 
 #[derive(Component, Copy, Clone, Debug, PartialEq, Eq, Default)]

src/lib.rs

@@ -5,7 +5,7 @@ pub mod query;
 pub mod systems;
 
 mod plugin {
-	use bevy::app::{PluginGroup, PluginGroupBuilder};
+	use bevy_app::{PluginGroup, PluginGroupBuilder};
 
 	use crate::loader;
 

src/loader.rs

@@ -26,8 +26,8 @@ impl Error for LoaderError {}
 
 #[cfg(feature = "json_loader")]
 mod json_loader {
-	use bevy::asset::io::Reader;
-	use bevy::asset::{AssetLoader, LoadContext};
+	use bevy_asset::io::Reader;
+	use bevy_asset::{AssetLoader, LoadContext};
 
 	use crate::definitions::AnimationSet;
 	use crate::loader::LoaderError;
@@ -62,8 +62,8 @@ mod json_loader {
 
 #[cfg(feature = "toml_loader")]
 mod toml_loader {
-	use bevy::asset::io::Reader;
-	use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext};
+	use bevy_asset::io::Reader;
+	use bevy_asset::{AssetLoader, AsyncReadExt, LoadContext};
 
 	use crate::definitions::AnimationSet;
 	use crate::loader::LoaderError;
@@ -97,8 +97,8 @@ mod toml_loader {
 }
 
 mod _plugin {
-	use bevy::app::{App, Plugin};
-	use bevy::asset::AssetApp;
+	use bevy_app::{App, Plugin};
+	use bevy_asset::AssetApp;
 
 	pub struct AnimationLoadersPlugin;
 	impl Plugin for AnimationLoadersPlugin {

src/query.rs

@@ -4,10 +4,14 @@ use crate::definitions::{
 };
 use crate::directionality::Directionality;
 use crate::systems::AnimationCompleted;
-use bevy::asset::Assets;
-use bevy::ecs::query::{QueryData, QueryFilter};
-use bevy::prelude::{Commands, Entity, EventWriter, Parent, Query, Res, Time, With, Without};
-use bevy::sprite::Sprite;
+use bevy_asset::Assets;
+use bevy_ecs::entity::Entity;
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::hierarchy::ChildOf;
+use bevy_ecs::query::{QueryData, QueryFilter, With, Without};
+use bevy_ecs::system::{Commands, Query, Res};
+use bevy_sprite::Sprite;
+use bevy_time::Time;
 
 #[derive(QueryData)]
 #[query_data(mutable)]
@@ -196,7 +200,7 @@ pub fn play_override_animation(
 				.remove::<(AnimationOverride, OverrideData)>();
 
 			if let Some(data) = data {
-				events.send(AnimationCompleted {
+				events.write(AnimationCompleted {
 					entity,
 					user_data: **data,
 				});
@@ -241,7 +245,7 @@ pub fn play_directional_override_animation(
 				.remove::<(AnimationOverride, OverrideData)>();
 
 			if let Some(data) = data {
-				events.send(AnimationCompleted {
+				events.write(AnimationCompleted {
 					entity,
 					user_data: **data,
 				});
@@ -266,11 +270,11 @@ pub fn play_simple_animation(
 }
 
 pub fn sync_child_animation(
-	mut children: Query<(&Parent, &mut Sprite), With<SyncToParent>>,
+	mut children: Query<(&ChildOf, &mut Sprite), With<SyncToParent>>,
 	parents: Query<&Sprite, Without<SyncToParent>>,
 ) {
 	for (parent, mut child_sprite) in &mut children {
-		if let Ok(parent_sprite) = parents.get(**parent) {
+		if let Ok(parent_sprite) = parents.get(parent.parent()) {
 			match (
 				parent_sprite.texture_atlas.as_ref(),
 				child_sprite.texture_atlas.as_mut(),

src/systems.rs

@@ -2,7 +2,10 @@ use crate::query::{
 	play_animations, play_directional_animations, play_directional_override_animation,
 	play_override_animation, play_simple_animation, sync_child_animation,
 };
-use bevy::prelude::*;
+use bevy_app::{App, Plugin, PostUpdate};
+use bevy_ecs::entity::Entity;
+use bevy_ecs::event::Event;
+use bevy_ecs::schedule::{IntoScheduleConfigs, SystemSet};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemSet)]
 pub enum AnimationSystems {
@@ -11,7 +14,6 @@ pub enum AnimationSystems {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Event)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct AnimationCompleted {
 	pub entity: Entity,
 	pub user_data: u128,