Add random number generator resources (optionally specified with a seed)

Author: LegNeato

crates/bevy_core/Cargo.toml

@@ -15,13 +15,16 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.5.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.5.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
-bevy_math = { path = "../bevy_math", version = "0.5.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+bevy_app = { path="../bevy_app", version="0.5.0" }
+bevy_derive = { path="../bevy_derive", version="0.5.0" }
+bevy_ecs = { path="../bevy_ecs", version="0.5.0" }
+bevy_math = { path="../bevy_math", version="0.5.0" }
+bevy_reflect = { path="../bevy_reflect", version="0.5.0", features=["bevy"] }
+bevy_tasks = { path="../bevy_tasks", version="0.5.0" }
+bevy_utils = { path="../bevy_utils", version="0.5.0" }
 
 # other
 bytemuck = "1.5"
+rand = { version="0.8", features=["getrandom", "small_rng", "std_rng"] }
+getrandom = { version="0.2", features=["js"] }
+rand_chacha = "0.3"

crates/bevy_core/src/lib.rs

@@ -2,19 +2,24 @@ mod bytes;
 mod float_ord;
 mod label;
 mod name;
+mod rng;
 mod task_pool_options;
 mod time;
 
 pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
 pub use name::*;
+pub use rng::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Name, Time, Timer};
+    pub use crate::{
+        CryptoRng, DefaultRngOptions, DefaultTaskPoolOptions, EntityLabels, InsecureRng, Labels,
+        Name, Rng, RngCore, SecureRng, Time, Timer, SliceRandom
+    };
 }
 
 use bevy_app::prelude::*;
@@ -46,6 +51,13 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(app.world_mut());
 
+        // Setup the default bevy random number generators
+        app.world_mut()
+            .get_resource::<DefaultRngOptions>()
+            .cloned()
+            .unwrap_or_else(DefaultRngOptions::default)
+            .create_default_rngs(app.world_mut());
+
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
             .init_resource::<FixedTimesteps>()

crates/bevy_core/src/rng.rs

@@ -0,0 +1,104 @@
+use bevy_ecs::world::World;
+use bevy_utils::tracing::trace;
+use getrandom::getrandom;
+pub use rand::{
+    rngs::{SmallRng, StdRng},
+    CryptoRng, Rng, RngCore, SeedableRng, seq::SliceRandom,
+};
+
+#[derive(Clone, Debug)]
+pub struct DefaultRngOptions {
+    /// The seed to use for secure / cryptographic operations.
+    pub secure_seed: [u8; 32],
+    /// The seed to use for insecure / non-cryptographic operations.
+    pub insecure_seed: [u8; 32],
+}
+
+impl Default for DefaultRngOptions {
+    fn default() -> Self {
+        let mut seed: [u8; 32] = [0; 32];
+        getrandom(&mut seed).expect("failed to get seed for crypto rng");
+
+        // The default is to use the same secure / cryptographic seed for both Rngs.
+        DefaultRngOptions {
+            secure_seed: seed,
+            insecure_seed: seed,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct SecureRng(StdRng);
+
+impl SecureRng {
+    fn from_seed(seed: [u8; 32]) -> Self {
+        SecureRng(StdRng::from_seed(seed))
+    }
+}
+impl RngCore for SecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+#[derive(Clone)]
+pub struct InsecureRng(SmallRng);
+
+impl InsecureRng {
+    fn from_seed(seed: [u8; 32]) -> Self {
+        InsecureRng(SmallRng::from_seed(seed))
+    }
+}
+impl RngCore for InsecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+impl DefaultRngOptions {
+    /// Create a configuration that forces using a particular secure seed.
+    pub fn with_secure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            secure_seed: seed,
+            ..Default::default()
+        }
+    }
+
+    /// Create a configuration that forces using a particular insecure seed.
+    pub fn with_insecure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            insecure_seed: seed,
+            ..Default::default()
+        }
+    }
+
+    /// Inserts the default Rngs into the given resource map based on the configured values.
+    pub fn create_default_rngs(&self, world: &mut World) {
+        if !world.contains_resource::<SecureRng>() {
+            trace!("Creating secure RNG with seed: {:x?}", self.secure_seed);
+            world.insert_resource(SecureRng::from_seed(self.secure_seed));
+        }
+        if !world.contains_resource::<InsecureRng>() {
+            trace!("Creating insecure RNG with seed: {:x?}", self.insecure_seed);
+            world.insert_resource(InsecureRng::from_seed(self.insecure_seed));
+        }
+    }
+}

examples/2d/contributors.rs

@@ -1,5 +1,4 @@
 use bevy::prelude::*;
-use rand::{prelude::SliceRandom, Rng};
 use std::{
     collections::BTreeSet,
     io::{BufRead, BufReader},
@@ -52,6 +51,7 @@ fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     let contribs = contributors();
 
@@ -65,16 +65,14 @@ fn setup(
         idx: 0,
     };
 
-    let mut rnd = rand::thread_rng();
-
     for name in contribs {
-        let pos = (rnd.gen_range(-400.0..400.0), rnd.gen_range(0.0..400.0));
-        let dir = rnd.gen_range(-1.0..1.0);
+        let pos = (rng.gen_range(-400.0..400.0), rng.gen_range(0.0..400.0));
+        let dir = rng.gen_range(-1.0..1.0);
         let velocity = Vec3::new(dir * 500.0, 0.0, 0.0);
-        let hue = rnd.gen_range(0.0..=360.0);
+        let hue = rng.gen_range(0.0..=360.0);
 
         // some sprites should be flipped
-        let flipped = rnd.gen_bool(0.5);
+        let flipped = rng.gen_bool(0.5);
 
         let transform = Transform::from_xyz(pos.0, pos.1, 0.0);
 
@@ -106,7 +104,7 @@ fn setup(
         sel.order.push((name, e));
     }
 
-    sel.order.shuffle(&mut rnd);
+    sel.order.shuffle(&mut *rng);
 
     commands.spawn_bundle((SelectTimer, Timer::from_seconds(SHOWCASE_TIMER_SECS, true)));
 
@@ -245,10 +243,9 @@ fn velocity_system(time: Res<Time>, mut q: Query<&mut Velocity>) {
 /// force.
 fn collision_system(
     wins: Res<Windows>,
+    mut rng: ResMut<InsecureRng>,
     mut q: Query<(&mut Velocity, &mut Transform), With<Contributor>>,
 ) {
-    let mut rnd = rand::thread_rng();
-
     let win = wins.get_primary().unwrap();
 
     let ceiling = win.height() / 2.;
@@ -267,7 +264,7 @@ fn collision_system(
         if bottom < ground {
             t.translation.y = ground + SPRITE_SIZE / 2.0;
             // apply an impulse upwards
-            v.translation.y = rnd.gen_range(700.0..1000.0);
+            v.translation.y = rng.gen_range(700.0..1000.0);
         }
         if top > ceiling {
             t.translation.y = ceiling - SPRITE_SIZE / 2.0;

examples/2d/many_sprites.rs

@@ -5,8 +5,6 @@ use bevy::{
     sprite::SpriteSettings,
 };
 
-use rand::Rng;
-
 const CAMERA_SPEED: f32 = 1000.0;
 
 pub struct PrintTimer(Timer);
@@ -32,10 +30,9 @@ fn main() {
 fn setup(
     mut commands: Commands,
     assets: Res<AssetServer>,
+    mut rng: ResMut<InsecureRng>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-    let mut rng = rand::thread_rng();
-
     let tile_size = Vec2::splat(64.0);
     let map_size = Vec2::splat(320.0);
 

examples/ecs/change_detection.rs

@@ -1,5 +1,4 @@
 use bevy::prelude::*;
-use rand::Rng;
 
 // This example illustrates how to react to component change
 fn main() {
@@ -20,9 +19,13 @@ fn setup(mut commands: Commands) {
     commands.spawn().insert(Transform::identity());
 }
 
-fn change_component(time: Res<Time>, mut query: Query<(Entity, &mut MyComponent)>) {
+fn change_component(
+    time: Res<Time>,
+    mut rng: ResMut<InsecureRng>,
+    mut query: Query<(Entity, &mut MyComponent)>,
+) {
     for (entity, mut component) in query.iter_mut() {
-        if rand::thread_rng().gen_bool(0.1) {
+        if rng.gen_bool(0.1) {
             info!("changing component {:?}", entity);
             component.0 = time.seconds_since_startup();
         }

examples/ecs/iter_combinations.rs

@@ -1,5 +1,4 @@
 use bevy::{core::FixedTimestep, prelude::*};
-use rand::{thread_rng, Rng};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
@@ -44,6 +43,7 @@ struct BodyBundle {
 
 fn generate_bodies(
     mut commands: Commands,
+    mut rng: ResMut<InsecureRng>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -56,7 +56,6 @@ fn generate_bodies(
     let color_range = 0.5..1.0;
     let vel_range = -0.5..0.5;
 
-    let mut rng = thread_rng();
     for _ in 0..NUM_BODIES {
         let mass_value_cube_root: f32 = rng.gen_range(0.5..4.0);
         let mass_value: f32 = mass_value_cube_root * mass_value_cube_root * mass_value_cube_root;

examples/game/alien_cake_addict.rs

@@ -4,7 +4,6 @@ use bevy::{
     prelude::*,
     render::{camera::Camera, render_graph::base::camera::CAMERA_3D},
 };
-use rand::Rng;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
 enum GameState {
@@ -98,7 +97,12 @@ fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
     commands.spawn_bundle(UiCameraBundle::default());
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMut<Game>) {
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut game: ResMut<Game>,
+    mut rng: ResMut<InsecureRng>,
+) {
     // reset the game state
     game.cake_eaten = 0;
     game.score = 0;
@@ -116,7 +120,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMu
         .map(|j| {
             (0..BOARD_SIZE_I)
                 .map(|i| {
-                    let height = rand::thread_rng().gen_range(-0.1..0.1);
+                    let height = rng.gen_range(-0.1..0.1);
                     commands
                         .spawn_bundle((
                             Transform::from_xyz(i as f32, height - 0.2, j as f32),
@@ -296,6 +300,7 @@ fn spawn_bonus(
     mut state: ResMut<State<GameState>>,
     mut commands: Commands,
     mut game: ResMut<Game>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     if *state.current() != GameState::Playing {
         return;
@@ -312,8 +317,8 @@ fn spawn_bonus(
 
     // ensure bonus doesn't spawn on the player
     loop {
-        game.bonus.i = rand::thread_rng().gen_range(0..BOARD_SIZE_I);
-        game.bonus.j = rand::thread_rng().gen_range(0..BOARD_SIZE_J);
+        game.bonus.i = rng.gen_range(0..BOARD_SIZE_I);
+        game.bonus.j = rng.gen_range(0..BOARD_SIZE_J);
         if game.bonus.i != game.player.i || game.bonus.j != game.player.j {
             break;
         }

examples/tools/bevymark.rs

@@ -2,7 +2,6 @@ use bevy::{
     diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin},
     prelude::*,
 };
-use rand::Rng;
 
 const BIRDS_PER_SECOND: u32 = 1000;
 const BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
@@ -116,9 +115,9 @@ fn mouse_handler(
     mut bird_material: ResMut<BirdMaterial>,
     mut counter: ResMut<BevyCounter>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut rnd: ResMut<InsecureRng>,
 ) {
     if mouse_button_input.just_pressed(MouseButton::Left) {
-        let mut rnd = rand::thread_rng();
         let color = gen_color(&mut rnd);
 
         let texture_handle = asset_server.load("branding/icon.png");
@@ -207,7 +206,10 @@ fn counter_system(
 ///
 /// Because there is no `Mul<Color> for Color` instead `[f32; 3]` is
 /// used.
-fn gen_color(rng: &mut impl Rng) -> [f32; 3] {
+fn gen_color<R>(rng: &mut ResMut<R>) -> [f32; 3]
+where
+    R: Rng + Sync + Send + 'static,
+{
     let r = rng.gen_range(0.2..1.0);
     let g = rng.gen_range(0.2..1.0);
     let b = rng.gen_range(0.2..1.0);