flax 0.7.1

An ergonomic archetypical ECS
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 crate::{
    archetype::{Archetype, Slice, Slot},
    fetch::PreparedFetch,
    filter::{next_slice, Filtered},
    Entity,
};

/// Iterates over a chunk of entities, specified by a predicate.
/// In essence, this is the unflattened version of [crate::QueryIter].
pub struct Chunk<'q, Q: PreparedFetch<'q>> {
    arch: &'q Archetype,
    fetch: Q::Chunk,
    pos: Slot,
    end: Slot,
}

impl<'q, Q: PreparedFetch<'q>> core::fmt::Debug for Chunk<'q, Q> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Batch")
            .field("pos", &self.pos)
            .field("end", &self.end)
            .finish()
    }
}

impl<'q, Q: PreparedFetch<'q>> Chunk<'q, Q> {
    pub(crate) fn new(arch: &'q Archetype, chunk: Q::Chunk, slice: Slice) -> Self {
        Self {
            arch,
            fetch: chunk,
            pos: slice.start,
            end: slice.end,
        }
    }

    pub(crate) fn slots(&self) -> Slice {
        Slice::new(self.pos, self.end)
    }

    /// Returns the archetype for this batch.
    /// **Note**: The borrow of the fetch is still held and may result in borrow
    /// errors.
    pub fn arch(&self) -> &Archetype {
        self.arch
    }

    /// Returns the number of items which would be yielded by this batch
    pub fn len(&self) -> usize {
        self.slots().len()
    }

    /// Returns true if the batch is empty
    pub fn is_empty(&self) -> bool {
        self.slots().is_empty()
    }
}

impl<'q, Q> Iterator for Chunk<'q, Q>
where
    Q: PreparedFetch<'q>,
{
    type Item = Q::Item;

    fn next(&mut self) -> Option<Q::Item> {
        if self.pos == self.end {
            None
        } else {
            // let fetch = unsafe { &mut *(self.fetch as *mut Q::Batch) };
            let item = unsafe { Q::fetch_next(&mut self.fetch) };
            self.pos += 1;
            Some(item)
        }
    }
}

impl<'q, Q> Chunk<'q, Q>
where
    Q: PreparedFetch<'q>,
{
    pub(crate) fn next_with_id(&mut self) -> Option<(Entity, Q::Item)> {
        if self.pos == self.end {
            None
        } else {
            let item = unsafe { Q::fetch_next(&mut self.fetch) };
            let id = self.arch.entities[self.pos];
            self.pos += 1;
            Some((id, item))
        }
    }

    pub(crate) fn next_full(&mut self) -> Option<(Slot, Entity, Q::Item)> {
        if self.pos == self.end {
            None
        } else {
            let slot = self.pos;
            let item = unsafe { Q::fetch_next(&mut self.fetch) };
            let id = self.arch.entities[slot];
            self.pos += 1;

            Some((slot, id, item))
        }
    }
}

/// An iterator over a single archetype which returns chunks.
/// The chunk size is determined by the largest continuous matched entities for
/// filters.
pub struct ArchetypeChunks<'q, Q, F> {
    pub(crate) arch: &'q Archetype,
    pub(crate) fetch: *mut Filtered<Q, F>,
    pub(crate) slots: Slice,
}

unsafe impl<'q, Q: 'q, F: 'q> Sync for ArchetypeChunks<'q, Q, F> where &'q mut Filtered<Q, F>: Sync {}
unsafe impl<'q, Q: 'q, F: 'q> Send for ArchetypeChunks<'q, Q, F> where &'q mut Filtered<Q, F>: Send {}

impl<'q, Q, F> Iterator for ArchetypeChunks<'q, Q, F>
where
    Q: 'q + PreparedFetch<'q>,
    F: 'q + PreparedFetch<'q>,
{
    type Item = Chunk<'q, Q>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        // Fetch will never change and all calls are disjoint
        let fetch = unsafe { &mut *self.fetch };

        // Get the next chunk
        let slots = next_slice(&mut self.slots, fetch)?;

        // Safety: Disjoint chunk
        let chunk = unsafe { fetch.create_chunk(slots) };
        let chunk = Chunk::new(self.arch, chunk, slots);

        Some(chunk)
    }
}