first-pass on splitting features,

Author: Bluefinger

crates/bevy_entropy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_entropy"
-version = "0.9.0"
+version = "0.11.0-dev"
 edition = "2021"
 description = "Bevy Engine's RNG integration"
 homepage = "https://bevyengine.org"
@@ -9,15 +9,21 @@ license = "MIT OR Apache-2.0"
 keywords = ["game", "bevy", "rand", "rng"]
 categories = ["game-engines", "algorithms"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+bevy_reflect = ["dep:bevy_reflect", "bevy_app/bevy_reflect", "serialize"]
+default = ["bevy_reflect"]
+serialize = ["dep:serde", "rand_core/serde1", "rand_chacha/serde1"]
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.9.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.9.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.9.0" }
-serde = { version = "1.0", features = ["derive"] }
-rand_core = { version = "0.6", features = ["std", "serde1"] }
-rand_chacha = { version = "0.3", features = ["serde1"] }
+# bevy
+bevy_app = { path = "../bevy_app", version = "0.9.0", default-features = false }
+bevy_ecs = { path = "../bevy_ecs", version = "0.9.0", default-features = false }
+bevy_reflect = { path = "../bevy_reflect", version = "0.9.0", optional = true }
+
+# others
+serde = { version = "1.0", features = ["derive"], optional = true }
+rand_core = { version = "0.6", features = ["std"] }
+rand_chacha = "0.3"
 
 [dev-dependencies]
 rand = "0.8"

crates/bevy_entropy/src/component.rs

@@ -1,17 +1,30 @@
 use std::fmt::Debug;
 
 use crate::{
-    thread_local_entropy::ThreadLocalEntropy,
     resource::GlobalEntropy,
+    thread_local_entropy::ThreadLocalEntropy,
     traits::{EntropySource, SeedableEntropySource},
-    Deserialize, RngCore, SeedableRng, Serialize,
 };
 use bevy_ecs::{prelude::Component, system::ResMut, world::Mut};
+use rand_core::{RngCore, SeedableRng};
+
+#[cfg(feature = "serialize")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "bevy_reflect")]
 use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize, ReflectSerialize};
 
-#[derive(Debug, Clone, PartialEq, Eq, Component, Reflect, FromReflect, Serialize, Deserialize)]
-#[serde(bound(deserialize = "R: for<'a> Deserialize<'a>"))]
-#[reflect_value(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Component)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect, FromReflect))]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serialize",
+    serde(bound(deserialize = "R: for<'a> Deserialize<'a>"))
+)]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect_value(Debug, PartialEq, Serialize, Deserialize)
+)]
 pub struct EntropyComponent<R: EntropySource + 'static>(R);
 
 impl<R: EntropySource + 'static> EntropyComponent<R> {
@@ -92,7 +105,9 @@ impl<R: SeedableEntropySource + 'static> From<&mut Mut<'_, R>> for EntropyCompon
     }
 }
 
-impl<R: SeedableEntropySource + 'static> From<&mut ResMut<'_, GlobalEntropy<R>>> for EntropyComponent<R> {
+impl<R: SeedableEntropySource + 'static> From<&mut ResMut<'_, GlobalEntropy<R>>>
+    for EntropyComponent<R>
+{
     fn from(rng: &mut ResMut<'_, GlobalEntropy<R>>) -> Self {
         Self::from_rng(rng.as_mut()).unwrap()
     }

crates/bevy_entropy/src/lib.rs

@@ -4,90 +4,6 @@
 pub mod component;
 pub mod prelude;
 pub mod resource;
+pub mod plugin;
 mod thread_local_entropy;
 mod traits;
-
-use std::marker::PhantomData;
-
-use bevy_app::{App, Plugin};
-use component::EntropyComponent;
-use rand_core::{RngCore, SeedableRng};
-use resource::GlobalEntropy;
-use serde::{Deserialize, Serialize};
-use traits::SeedableEntropySource;
-
-/// Plugin for integrating a PRNG that implements `RngCore` into
-/// the bevy engine, registering types for a global resource and
-/// entropy components.
-///
-/// ```
-/// use bevy_ecs::prelude::ResMut;
-/// use bevy_app::App;
-/// use bevy_entropy::prelude::*;
-/// use rand_core::RngCore;
-/// use rand_chacha::ChaCha8Rng;
-///
-/// fn main() {
-///  App::new()
-///    .add_plugin(EntropyPlugin::<ChaCha8Rng>::default())
-///    .add_system(print_random_value)
-///    .run();
-/// }
-///
-/// fn print_random_value(mut rng: ResMut<GlobalEntropy<ChaCha8Rng>>) {
-///   println!("Random value: {}", rng.next_u32());
-/// }
-/// ```
-pub struct EntropyPlugin<R: SeedableEntropySource + 'static> {
-    seed: Option<R::Seed>,
-    _marker: PhantomData<&'static mut R>,
-}
-
-impl<R: SeedableEntropySource + 'static> EntropyPlugin<R>
-where
-    R::Seed: Send + Sync + Copy,
-{
-    #[inline]
-    #[must_use]
-    pub fn new() -> Self {
-        Self {
-            seed: None,
-            _marker: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn with_seed(mut self, seed: R::Seed) -> Self {
-        self.seed = Some(seed);
-        self
-    }
-}
-
-impl<R: SeedableEntropySource + 'static> Default for EntropyPlugin<R>
-where
-    R::Seed: Send + Sync + Copy,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<R: SeedableEntropySource + 'static> Plugin for EntropyPlugin<R>
-where
-    R::Seed: Send + Sync + Copy,
-{
-    fn build(&self, app: &mut App) {
-        app.register_type::<GlobalEntropy<R>>()
-            .register_type::<EntropyComponent<R>>();
-
-        if let Some(seed) = self.seed {
-            app.insert_resource(GlobalEntropy::<R>::from_seed(seed));
-        } else {
-            app.init_resource::<GlobalEntropy<R>>();
-        }
-    }
-
-    fn is_unique(&self) -> bool {
-        false
-    }
-}

crates/bevy_entropy/src/plugin.rs

@@ -0,0 +1,85 @@
+use std::marker::PhantomData;
+
+use crate::{resource::GlobalEntropy, traits::SeedableEntropySource};
+use bevy_app::{App, Plugin};
+use rand_core::SeedableRng;
+
+#[cfg(feature = "bevy_reflect")]
+use crate::component::EntropyComponent;
+
+/// Plugin for integrating a PRNG that implements `RngCore` into
+/// the bevy engine, registering types for a global resource and
+/// entropy components.
+///
+/// ```
+/// use bevy_ecs::prelude::ResMut;
+/// use bevy_app::App;
+/// use bevy_entropy::prelude::*;
+/// use rand_core::RngCore;
+/// use rand_chacha::ChaCha8Rng;
+///
+/// fn main() {
+///  App::new()
+///    .add_plugin(EntropyPlugin::<ChaCha8Rng>::default())
+///    .add_system(print_random_value)
+///    .run();
+/// }
+///
+/// fn print_random_value(mut rng: ResMut<GlobalEntropy<ChaCha8Rng>>) {
+///   println!("Random value: {}", rng.next_u32());
+/// }
+/// ```
+pub struct EntropyPlugin<R: SeedableEntropySource + 'static> {
+    seed: Option<R::Seed>,
+    _marker: PhantomData<&'static mut R>,
+}
+
+impl<R: SeedableEntropySource + 'static> EntropyPlugin<R>
+where
+    R::Seed: Send + Sync + Copy,
+{
+    #[inline]
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            seed: None,
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn with_seed(mut self, seed: R::Seed) -> Self {
+        self.seed = Some(seed);
+        self
+    }
+}
+
+impl<R: SeedableEntropySource + 'static> Default for EntropyPlugin<R>
+where
+    R::Seed: Send + Sync + Copy,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<R: SeedableEntropySource + 'static> Plugin for EntropyPlugin<R>
+where
+    R::Seed: Send + Sync + Copy,
+{
+    fn build(&self, app: &mut App) {
+        #[cfg(feature = "bevy_reflect")]
+        app.register_type::<GlobalEntropy<R>>()
+            .register_type::<EntropyComponent<R>>();
+
+        if let Some(seed) = self.seed {
+            app.insert_resource(GlobalEntropy::<R>::from_seed(seed));
+        } else {
+            app.init_resource::<GlobalEntropy<R>>();
+        }
+    }
+
+    fn is_unique(&self) -> bool {
+        false
+    }
+}

crates/bevy_entropy/src/prelude.rs

@@ -1,3 +1,3 @@
 pub use crate::component::EntropyComponent;
 pub use crate::resource::GlobalEntropy;
-pub use crate::EntropyPlugin;
+pub use crate::plugin::EntropyPlugin;

crates/bevy_entropy/src/resource.rs

@@ -1,15 +1,26 @@
 use std::fmt::Debug;
 
-use crate::{
-    traits::{EntropySource, SeedableEntropySource},
-    Deserialize, RngCore, SeedableRng, Serialize,
-};
+use crate::traits::{EntropySource, SeedableEntropySource};
 use bevy_ecs::prelude::Resource;
+use rand_core::{RngCore, SeedableRng};
+
+#[cfg(feature = "serialize")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "bevy_reflect")]
 use bevy_reflect::{FromReflect, Reflect, ReflectDeserialize, ReflectSerialize};
 
-#[derive(Debug, Clone, PartialEq, Eq, Resource, Reflect, FromReflect, Serialize, Deserialize)]
-#[serde(bound(deserialize = "R: for<'a> Deserialize<'a>"))]
-#[reflect_value(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Resource)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect, FromReflect))]
+#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serialize",
+    serde(bound(deserialize = "R: for<'a> Deserialize<'a>"))
+)]
+#[cfg_attr(
+    all(feature = "serialize", feature = "bevy_reflect"),
+    reflect_value(Debug, PartialEq, Serialize, Deserialize)
+)]
 pub struct GlobalEntropy<R: EntropySource + 'static>(R);
 
 impl<R: EntropySource + 'static> GlobalEntropy<R> {

crates/bevy_entropy/src/thread_local_entropy.rs

@@ -1,7 +1,7 @@
 use std::{cell::UnsafeCell, rc::Rc};
 
-use crate::{RngCore, SeedableRng};
 use rand_chacha::ChaCha12Rng;
+use rand_core::{RngCore, SeedableRng};
 
 thread_local! {
     // We require `Rc` to avoid premature freeing when `ThreadLocalEntropy` is used within thread-local destructors.

crates/bevy_entropy/src/traits.rs

@@ -1,17 +1,40 @@
 use std::fmt::Debug;
 
-use crate::{Deserialize, RngCore, SeedableRng, Serialize};
+use rand_core::{RngCore, SeedableRng};
 
+#[cfg(feature = "serialize")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "serialize")]
 pub trait EntropySource:
-    RngCore + Clone + Debug + PartialEq + Sync + Send + Serialize + for<'a> Deserialize<'a>
+    RngCore
+    + Clone
+    + Debug
+    + PartialEq
+    + Sync
+    + Send
+    + Serialize
+    + for<'a> Deserialize<'a>
+    + private::SealedEntropy
 {
 }
 
+#[cfg(feature = "serialize")]
 impl<T> EntropySource for T where
     T: RngCore + Clone + Debug + PartialEq + Sync + Send + Serialize + for<'a> Deserialize<'a>
 {
 }
 
+#[cfg(not(feature = "serialize"))]
+pub trait EntropySource:
+    RngCore + Clone + Debug + PartialEq + Sync + Send + private::SealedEntropy
+{
+}
+
+#[cfg(not(feature = "serialize"))]
+impl<T> EntropySource for T where T: RngCore + Clone + Debug + PartialEq + Sync + Send {}
+
+#[cfg(feature = "serialize")]
 pub trait SeedableEntropySource:
     RngCore
     + SeedableRng
@@ -22,9 +45,11 @@ pub trait SeedableEntropySource:
     + Send
     + Serialize
     + for<'a> Deserialize<'a>
+    + private::SealedSeedable
 {
 }
 
+#[cfg(feature = "serialize")]
 impl<T> SeedableEntropySource for T where
     T: RngCore
         + SeedableRng
@@ -37,3 +62,23 @@ impl<T> SeedableEntropySource for T where
         + for<'a> Deserialize<'a>
 {
 }
+
+#[cfg(not(feature = "serialize"))]
+pub trait SeedableEntropySource:
+    RngCore + SeedableRng + Clone + Debug + PartialEq + Sync + Send + private::SealedSeedable
+{
+}
+
+#[cfg(not(feature = "serialize"))]
+impl<T> SeedableEntropySource for T where
+    T: RngCore + SeedableRng + Clone + Debug + PartialEq + Sync + Send
+{
+}
+
+mod private {
+    pub trait SealedEntropy {}
+    pub trait SealedSeedable {}
+
+    impl<T: super::EntropySource> SealedEntropy for T {}
+    impl<T: super::SeedableEntropySource> SealedSeedable for T {}
+}

crates/bevy_internal/Cargo.toml

@@ -58,7 +58,7 @@ symphonia-wav = ["bevy_audio/symphonia-wav"]
 # Enable watching file system for asset hot reload
 filesystem_watcher = ["bevy_asset/filesystem_watcher"]
 
-serialize = ["bevy_core/serialize", "bevy_input/serialize", "bevy_time/serialize", "bevy_window/serialize", "bevy_transform/serialize", "bevy_math/serialize", "bevy_scene/serialize"]
+serialize = ["bevy_core/serialize", "bevy_input/serialize", "bevy_time/serialize", "bevy_window/serialize", "bevy_transform/serialize", "bevy_math/serialize", "bevy_scene/serialize", "bevy_entropy?/serialize"]
 
 # Display server protocol support (X11 is enabled by default)
 wayland = ["bevy_winit/wayland"]