flecs_ecs 0.2.2

Rust API for the C/CPP flecs ECS library <https://github.com/SanderMertens/flecs>
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::prelude::*;
use crate::sys;

/// Register opaque type interface
impl<'a, T: 'static> Component<'a, T> {
    pub fn opaque_func<Func>(&self, func: Func) -> &Self
    where
        Func: FnOnce(WorldRef<'a>) -> Opaque<'a, T>,
    {
        let mut opaque = func(self.world());
        opaque.desc.entity = self.world().component_id_map::<T>();
        unsafe { sys::ecs_opaque_init(self.world_ptr_mut(), &opaque.desc) };
        self
    }

    pub fn opaque_func_id<Func, Elem>(&self, id: impl Into<Entity>, func: Func) -> &Self
    where
        Func: FnOnce(WorldRef<'a>) -> Opaque<'a, T, Elem>,
    {
        let mut opaque = func(self.world());
        opaque.desc.entity = *id.into();
        unsafe { sys::ecs_opaque_init(self.world_ptr_mut(), &opaque.desc) };
        self
    }

    pub fn opaque<Type: 'static>(&self) -> Opaque<'a, T> {
        let id = self.world().component_id_map::<Type>();
        let mut opaque = Opaque::<T>::new(self.world());
        opaque.as_type(id);
        opaque
    }

    pub fn opaque_id(&self, id: impl IntoEntity) -> Opaque<'a, T> {
        let id = id.into_entity(self.world());
        let mut opaque = Opaque::<T>::new(self.world());
        opaque.as_type(id);
        opaque
    }

    pub fn opaque_dyn_id<E>(&self, id_type: E, id_field: E) -> Opaque<'a, T>
    where
        E: Into<Entity> + Copy,
    {
        let mut opaque = Opaque::<T>::new_id(self.world(), id_type);
        opaque.as_type(id_field);
        opaque
    }

    /// Return opaque type builder for collection type
    ///
    /// ```
    /// use flecs_ecs::prelude::*;
    /// let world = World::new();
    ///
    /// #[derive(Component)]
    /// struct SerVec {
    ///     pub value: Vec<i32>,
    /// }
    ///
    /// world
    ///     .component::<SerVec>()
    ///     .opaque_collection_vector::<i32>();
    /// ```
    pub fn opaque_collection_vector<ElemType: 'static>(&self) -> Opaque<'a, T, ElemType> {
        let world = self.world();
        let mut opaque = Opaque::<T, ElemType>::new(self.world());
        let id = world.vector::<ElemType>();
        opaque.as_type(id);
        opaque
    }

    /// Return opaque type builder for collection type
    ///
    /// ```
    /// use flecs_ecs::prelude::*;
    /// let world = World::new();
    ///
    /// #[derive(Component)]
    /// struct SerVec {
    ///     pub value: Vec<i32>,
    /// }
    ///
    /// world
    ///     .component::<SerVec>()
    ///     .opaque_collection_dyn::<i32>(world.vector::<i32>());
    /// ```
    pub fn opaque_collection_dyn<ElemType>(
        &self,
        id: impl Into<Entity>,
    ) -> Opaque<'a, T, ElemType> {
        let id: Entity = id.into();
        let copy_id = id;
        let mut opaque = Opaque::<T, ElemType>::new_id(self.world(), self.id);
        opaque.as_type(copy_id);
        opaque
    }
}

impl<T: EnumComponentInfo + 'static> Component<'_, T> {
    /// Add constant.
    pub fn constant(&self, name: &str, value: T) -> &Self {
        unsafe { sys::ecs_add_id(self.world_ptr_mut(), *self.id, flecs::meta::EcsEnum::ID) };

        let name = compact_str::format_compact!("{}\0", name);

        let desc = sys::ecs_entity_desc_t {
            name: name.as_ptr() as *const _,
            parent: *self.id,
            ..Default::default()
        };

        let eid = unsafe { sys::ecs_entity_init(self.world_ptr_mut(), &desc) };

        ecs_assert!(
            eid != 0,
            FlecsErrorCode::InternalError,
            "failed to create entity"
        );

        let id = self.world().component_id::<T::UnderlyingTypeOfEnum>();

        let pair = ecs_pair(flecs::Constant::ID, *id);

        unsafe {
            let size = const { core::mem::size_of::<T::UnderlyingTypeOfEnum>() };
            let ptr = sys::ecs_ensure_id(self.world_ptr_mut(), eid, pair, size)
                as *mut T::UnderlyingTypeOfEnum;
            *ptr = *(&value as *const T as *const <T as ComponentId>::UnderlyingTypeOfEnum);
            sys::ecs_modified_id(self.world_ptr_mut(), eid, pair);
        }

        self
        //feature
        //#[cfg(feature = "flecs_rust_no_enum_reflection")]
        //TODO manual registration enum constant
    }
}