Struct Snapshot

pub struct Snapshot {
    pub entities: EntityMap,
    pub resources: ReflectMap,
}

Available on crate feature reflect only.

A collection of serializable entities and resources.

Can be serialized via SnapshotSerializer and deserialized via SnapshotDeserializer.

Fields

entities: EntityMap

Entities contained in the snapshot.

resources: ReflectMap

Resources contained in the snapshot.

Implementations

impl Snapshot

pub fn from_world(world: &World) -> Self

Returns a complete Snapshot of the current World state.

Contains all saveable entities and resources.

Shortcut for

Snapshot::builder(world)
    .extract_all()
    .build();

pub fn builder(world: &World) -> BuilderRef<'_>

Create a BuilderRef from the World, allowing you to create partial or filtered snapshots.

Example

Snapshot::builder(world)
    // Extract all matching entities and resources
    .extract_all()

    // Clear all extracted entities without any components
    .clear_empty()

    // Build the `Snapshot`
    .build();

impl Snapshot

pub fn entities(&self) -> &[DynamicEntity]

Returns a reference to the slice of entities contained in the Snapshot.

pub fn resources(&self) -> &[Box<dyn PartialReflect>]

Returns a reference to the slice of resources contained in the Snapshot.

impl Snapshot

pub fn apply(&self, world: &mut World) -> Result<(), Error>

Apply the Snapshot to the World, using default applier settings.

Errors

If a type included in the Snapshot has not been registered with the type registry.

pub fn applier<'w, 'i>(&'i self, world: &'w mut World) -> ApplierRef<'w, 'i>

Create an ApplierRef from the Snapshot and the World.

This allows you to specify an entity map, hook, etc.

Example

let snapshot = Snapshot::from_world(world);

snapshot
    .applier(world)
    .hook(move |entity, cmds| {
        // You can use the hook to add, get, or remove Components
        if !entity.contains::<ChildOf>() {
            cmds.insert(ChildOf(parent));
        }
    })
    .apply();

pub fn serializer<'a>( &'a self, registry: &'a TypeRegistry, ) -> SnapshotSerializer<'a>

Create a SnapshotSerializer from the Snapshot and the TypeRegistry.

pub fn deserializer(registry: &TypeRegistry) -> SnapshotDeserializer<'_>

Create a SnapshotDeserializer from the TypeRegistry.

Trait Implementations

impl CaptureDeserialize for Snapshot

type Seed<'a> = SnapshotDeserializerArc

The seed used for deserialization

fn seed(world: &World) -> Self::Seed<'_>

Create a deserialization seed from the world

impl<P> CaptureInput<P> for Snapshot

type Builder = Builder

The builder type passed to flow systems

fn builder(_pathway: &P, _world: &World) -> Self::Builder

Creates the builder from the given Pathway and World

fn build(builder: Self::Builder, _pathway: &P, _world: &World) -> Self

Builds the capture type

impl<P> CaptureOutput<P> for Snapshot

type Builder = Applier<'static>

The builder type passed to flow systems

type Error = Error

Error potentially thrown while building

fn builder(self, _pathway: &P, _world: &mut World) -> Self::Builder

Creates the builder from the given Pathway and World

fn build( builder: Self::Builder, _pathway: &P, world: &mut World, ) -> Result<Self, Self::Error>

Builds the capture type

impl CaptureSerialize for Snapshot

type Value<'a> = SnapshotSerializerArc<'a> where Self: 'a

The serializable value

fn value<'a>(&'a self, world: &'a World) -> Self::Value<'a>

Convert a reference into a serializable value

impl Clone for Snapshot

fn clone(&self) -> Snapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Snapshot

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

Formats the value using the given formatter.

impl From<PipelineCapture> for Snapshot

fn from(value: PipelineCapture) -> Self

Converts to this type from the input type.

impl From<Snapshot> for PipelineCapture

fn from(value: Snapshot) -> Self

Converts to this type from the input type.

impl FromReflect for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialReflect for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply 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 try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

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

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

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

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

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

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

Casts this type to a mutable, fully-reflected value.

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

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

impl Struct for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

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

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

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

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Snapshot

where Snapshot: Any + Send + Sync,

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 Typed for Snapshot

where Snapshot: Any + Send + Sync, EntityMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ReflectMap: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.