bevy_save 2.0.1+4

A framework for saving and loading application state in Bevy.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use bevy::{
    ecs::entity::Entity,
    reflect::Reflect,
};

use crate::reflect::ReflectMap;

/// A reflection-powered serializable representation of an entity and its components.
#[derive(Reflect, Clone, Debug)]
#[reflect(Clone)]
#[type_path = "bevy_save"]
pub struct DynamicEntity {
    /// The identifier of the entity, unique within a scene
    /// (and the world it may have been generated from).
    ///
    /// Components that reference this entity must consistently use this identifier.
    pub entity: Entity,
    /// A map of boxed components that belong to the given entity and
    /// implement the [`PartialReflect`](bevy::reflect::PartialReflect) trait.
    pub components: ReflectMap,
}

impl From<bevy::scene::DynamicEntity> for DynamicEntity {
    fn from(value: bevy::scene::DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { std::mem::transmute(value) }
    }
}

impl From<DynamicEntity> for bevy::scene::DynamicEntity {
    fn from(value: DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { std::mem::transmute(value) }
    }
}

impl From<&bevy::scene::DynamicEntity> for &DynamicEntity {
    fn from(value: &bevy::scene::DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { &*std::ptr::from_ref(value).cast() }
    }
}

impl From<&DynamicEntity> for &bevy::scene::DynamicEntity {
    fn from(value: &DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { &*std::ptr::from_ref(value).cast() }
    }
}

impl From<&mut bevy::scene::DynamicEntity> for &mut DynamicEntity {
    fn from(value: &mut bevy::scene::DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { &mut *std::ptr::from_mut(value).cast() }
    }
}

impl From<&mut DynamicEntity> for &mut bevy::scene::DynamicEntity {
    fn from(value: &mut DynamicEntity) -> Self {
        // SAFETY: DynamicEntity and bevy::scene::DynamicEntity are equivalent
        unsafe { &mut *std::ptr::from_mut(value).cast() }
    }
}

#[cfg(test)]
mod test {
    use bevy::prelude::*;

    #[test]
    fn assert_dynamic_entity_matches() {
        let a = bevy::scene::DynamicEntity {
            entity: Entity::PLACEHOLDER,
            components: Vec::new(),
        };

        let b = super::DynamicEntity {
            entity: Entity::PLACEHOLDER,
            components: Vec::new().into(),
        };

        assert_eq!(std::mem::size_of_val(&a), std::mem::size_of_val(&b));
        assert_eq!(
            std::mem::size_of_val(&a.entity),
            std::mem::size_of_val(&b.entity)
        );
        assert_eq!(
            std::mem::size_of_val(&a.components),
            std::mem::size_of_val(&b.components)
        );
    }
}