shiv 0.1.0-alpha.10

A simple modern Entity Component System
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
138

use std::{
    any::{self, TypeId},
    mem::{self, MaybeUninit},
};

use crate::{
    hash_map::HashSet,
    storage::{ComponentStorage, StorageType, Storages},
    world::{Component, ComponentId, Components, Entity},
};

use ahash::HashMap;
pub use shiv_macro::Bundle;

pub unsafe trait Bundle: Send + Sync + 'static {
    type Iter: Iterator<Item = *mut u8>;

    fn components(components: &mut Components) -> Vec<ComponentId>;

    unsafe fn get_components(bundle: *mut Self) -> Self::Iter;
}

unsafe impl<T: Component> Bundle for T {
    type Iter = std::iter::Once<*mut u8>;

    #[inline]
    fn components(components: &mut Components) -> Vec<ComponentId> {
        vec![components.init_component::<T>()]
    }

    #[inline]
    unsafe fn get_components(bundle: *mut Self) -> Self::Iter {
        std::iter::once(bundle as *mut u8)
    }
}

#[derive(Clone, Debug)]
pub struct BundleInfo {
    component_ids: Vec<ComponentId>,
}

impl BundleInfo {
    #[inline]
    pub fn new<T: Bundle>(components: &mut Components) -> Self {
        let component_ids = T::components(components);

        let mut unique = HashSet::default();
        for id in component_ids.iter() {
            if !unique.insert(*id) {
                panic!(
                    "Bundle {} contains duplicate component",
                    any::type_name::<T>()
                );
            }
        }

        Self { component_ids }
    }

    /// # Safety
    /// - `components` must be the same as the `Components` used to create this `BundleInfo`.
    /// - `bundle` must be a valid instance of the bundle type `self` was created for.
    #[inline]
    pub unsafe fn insert<T: Bundle>(
        &self,
        entity: Entity,
        mut bundle: T,
        components: &mut Components,
        storages: &mut Storages,
        change_tick: u32,
    ) {
        for (i, data) in unsafe { T::get_components(&mut bundle).enumerate() } {
            let component_id = unsafe { self.component_ids.get_unchecked(i) };
            let info = unsafe { components.get_unchecked(*component_id) };

            match info.storage_type() {
                StorageType::Dense => {
                    let storage = storages.dense.get_or_init(info);
                    unsafe { storage.insert(entity, data, change_tick) };
                }
                _ => unreachable!(),
            }
        }

        mem::forget(bundle);
    }

    /// # Safety
    /// - `components` must be the same as the `Components` used to create this `BundleInfo`.
    /// - `T` must be the same as the bundle type `self` was created for.
    pub unsafe fn remove<T: Bundle>(
        &self,
        entity: Entity,
        components: &mut Components,
        storages: &mut Storages,
    ) -> Option<T> {
        for &component_id in self.component_ids.iter() {
            if !storages.contains(component_id, entity) {
                return None;
            }
        }

        let mut bundle = MaybeUninit::<T>::uninit();

        for (i, data) in unsafe { T::get_components(bundle.as_mut_ptr()).enumerate() } {
            let component_id = unsafe { *self.component_ids.get_unchecked(i) };
            let info = unsafe { components.get_unchecked(component_id) };

            match info.storage_type() {
                StorageType::Dense => {
                    let storage = storages.dense.get_mut(component_id)?;
                    unsafe { storage.remove_unchecked(entity, data) };
                }
                _ => unreachable!(),
            }
        }

        Some(unsafe { bundle.assume_init() })
    }
}

#[derive(Clone, Debug, Default)]
pub struct Bundles {
    bundles: HashMap<TypeId, BundleInfo>,
}

impl Bundles {
    #[inline]
    pub fn get(&self, type_id: TypeId) -> Option<&BundleInfo> {
        self.bundles.get(&type_id)
    }

    #[inline]
    pub fn init_bundle<T: Bundle>(&mut self, components: &mut Components) -> &BundleInfo {
        let id = TypeId::of::<T>();
        (self.bundles.entry(id)).or_insert_with(|| BundleInfo::new::<T>(components))
    }
}