Struct bevy_rand::resource::GlobalEntropy

pub struct GlobalEntropy<R: SeedableEntropySource + 'static>(/* private fields */);

A Global RngCore instance, meant for use as a Resource. Gets created automatically with crate::plugin::EntropyPlugin, or can be created and added manually.

Example

use bevy::prelude::*;
use bevy_prng::ChaCha8Rng;
use bevy_rand::prelude::GlobalEntropy;
use rand_core::RngCore;

fn print_random_value(mut rng: ResMut<GlobalEntropy<ChaCha8Rng>>) {
  println!("Random value: {}", rng.next_u32());
}

Implementations

impl<R: SeedableEntropySource + 'static> GlobalEntropy<R>

pub fn new(rng: R) -> Self

Create a new resource from a RngCore instance.

impl<R: SeedableEntropySource + 'static> GlobalEntropy<R>

pub fn reseed(&mut self, seed: R::Seed)

Reseeds the internal RngCore instance with a new seed.

Trait Implementations

impl<R: Clone + SeedableEntropySource + 'static> Clone for GlobalEntropy<R>

fn clone(&self) -> GlobalEntropy<R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug + SeedableEntropySource + 'static> Debug for GlobalEntropy<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: SeedableEntropySource + 'static> Default for GlobalEntropy<R>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, R> Deserialize<'de> for GlobalEntropy<R>

where R: for<'a> Deserialize<'a> + SeedableEntropySource + 'static,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> ForkableAsRng for GlobalEntropy<R>

where R: SeedableEntropySource + 'static,

type Output<T> = EntropyComponent<T> where T: SeedableEntropySource

The type of instance that is to be forked from the original source.

fn fork_as<T: SeedableEntropySource>(&mut self) -> Self::Output<T>

Fork the original instance to yield a new instance with a generated seed. This method allows one to specify the RNG algorithm to be used for the forked instance.

impl<R> ForkableInnerRng for GlobalEntropy<R>

where R: SeedableEntropySource + 'static,

type Output = R

The type of instance that is to be forked from the original source.

fn fork_inner(&mut self) -> Self::Output

Fork the original instance to yield a new instance with a generated seed. This method yields the inner PRNG instance directly as a forked instance.

impl<R> ForkableRng for GlobalEntropy<R>

where R: SeedableEntropySource + 'static,

type Output = EntropyComponent<R>

The type of instance that is to be forked from the original source.

fn fork_rng(&mut self) -> Self::Output

Fork the original instance to yield a new instance with a generated seed. This method preserves the RNG algorithm between original and forked instances.

impl<R: SeedableEntropySource + 'static> From<&mut R> for GlobalEntropy<R>

fn from(value: &mut R) -> Self

Converts to this type from the input type.

impl<R: SeedableEntropySource + 'static> From<R> for GlobalEntropy<R>

fn from(value: R) -> Self

Converts to this type from the input type.

impl<R> FromReflect for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + FromReflect + SeedableEntropySource + 'static,

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<R> GetTypeRegistration for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + FromReflect + SeedableEntropySource + 'static,

fn get_type_registration() -> TypeRegistration

impl<R: PartialEq + SeedableEntropySource + 'static> PartialEq for GlobalEntropy<R>

fn eq(&self, other: &GlobalEntropy<R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R> Reflect for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + FromReflect + SeedableEntropySource + 'static,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the [TypeInfo] of the type represented by this value.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn debug(&self, f: &mut Formatter<'_>) -> Result

Debug formatter for the value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<R: SeedableEntropySource + 'static> RngCore for GlobalEntropy<R>

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

fn fill_bytes(&mut self, dest: &mut [u8])

Fill dest with random data.

fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>

Fill dest entirely with random data.

impl<R: SeedableEntropySource + 'static> SeedableRng for GlobalEntropy<R>

fn from_entropy() -> Self

Creates a new instance of the RNG seeded via [ThreadLocalEntropy]. This method is the recommended way to construct non-deterministic PRNGs since it is convenient and secure. It overrides the standard SeedableRng::from_entropy method while the thread_local_entropy feature is enabled.

Panics

If [ThreadLocalEntropy] cannot get initialised because getrandom is unable to provide secure entropy, this method will panic.

type Seed = <R as SeedableRng>::Seed

Seed type, which is restricted to types mutably-dereferenceable as u8 arrays (we recommend [u8; N] for some N).

fn from_seed(seed: Self::Seed) -> Self

Create a new PRNG using the given seed.

fn seed_from_u64(state: u64) -> Self

Create a new PRNG using a u64 seed.

fn from_rng<R>(rng: R) -> Result<Self, Error>

where R: RngCore,

Create a new PRNG seeded from another Rng.

impl<R> Serialize for GlobalEntropy<R>

where R: Serialize + SeedableEntropySource + 'static,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R> TupleStruct for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + FromReflect + SeedableEntropySource + 'static,

fn field(&self, index: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn field_len(&self) -> usize

Returns the number of fields in the tuple struct.

fn iter_fields(&self) -> TupleStructFieldIter<'_>

Returns an iterator over the values of the tuple struct’s fields.

fn clone_dynamic(&self) -> DynamicTupleStruct

Clones the struct into a [DynamicTupleStruct].

impl<R> TypePath for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + SeedableEntropySource + 'static,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<R> Typed for GlobalEntropy<R>

where Self: Any + Send + Sync, R: TypePath + FromReflect + SeedableEntropySource + 'static,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<R: SeedableEntropySource + 'static> EcsEntropySource for GlobalEntropy<R>

impl<R: Eq + SeedableEntropySource + 'static> Eq for GlobalEntropy<R>

impl<R: SeedableEntropySource + 'static> Resource for GlobalEntropy<R>

where Self: Send + Sync + 'static,

impl<R: SeedableEntropySource + 'static> StructuralPartialEq for GlobalEntropy<R>