dynamis-world 0.7.0

Host scene registry, step orchestration, and readback
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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Run {
    pub(crate) offset: u32,
    pub(crate) len: u32,
}

impl Run {
    pub(crate) const EMPTY: Self = Self { offset: 0, len: 0 };

    pub(crate) fn span(self) -> std::ops::Range<usize> {
        self.offset as usize..(self.offset + self.len) as usize
    }
}

#[derive(Clone)]
pub(crate) struct Arena {
    free: Vec<Run>,
    used: u32,
}

pub(crate) fn merged(mut runs: Vec<Run>, live: u32) -> Vec<Run> {
    runs.retain_mut(|run| {
        if run.offset >= live {
            return false;
        }
        run.len = run.len.min(live - run.offset);
        true
    });
    runs.sort_unstable_by_key(|run| run.offset);
    let mut coalesced: Vec<Run> = Vec::with_capacity(runs.len());
    for run in runs {
        match coalesced.last_mut() {
            Some(previous) if previous.offset + previous.len >= run.offset => {
                previous.len = previous.offset.max(run.offset + run.len) - previous.offset;
            }
            _ => coalesced.push(run),
        }
    }
    coalesced
}

impl Arena {
    pub(crate) const fn new() -> Self {
        Self {
            free: Vec::new(),
            used: 0,
        }
    }

    pub(crate) fn used(&self) -> u32 {
        self.used
    }

    pub(crate) fn take(&mut self, len: u32) -> Run {
        assert!(len > 0, "an arena run must hold at least one slot");
        let recycled = self
            .free
            .iter()
            .position(|run| run.len >= len)
            .map(|index| {
                let run = self.free.swap_remove(index);
                if run.len > len {
                    self.free.push(Run {
                        offset: run.offset + len,
                        len: run.len - len,
                    });
                }
                run.offset
            });
        let offset = recycled.unwrap_or_else(|| {
            let offset = self.used;
            self.used += len;
            offset
        });
        self.used = self.used.max(offset + len);
        Run { offset, len }
    }

    pub(crate) fn release(&mut self, run: Run) {
        assert!(run.len > 0, "an arena run must hold at least one slot");
        assert!(
            run.offset + run.len <= self.used,
            "an arena run must sit below the arena watermark"
        );
        let mut merged = run;
        self.free.retain(|candidate| {
            if candidate.offset + candidate.len == merged.offset {
                merged = Run {
                    offset: candidate.offset,
                    len: candidate.len + merged.len,
                };
                false
            } else if merged.offset + merged.len == candidate.offset {
                merged = Run {
                    offset: merged.offset,
                    len: merged.len + candidate.len,
                };
                false
            } else {
                true
            }
        });
        self.free.push(merged);
        self.trim();
    }

    fn trim(&mut self) {
        while let Some(index) = self
            .free
            .iter()
            .position(|run| run.offset + run.len == self.used)
        {
            let run = self.free.swap_remove(index);
            self.used = run.offset;
        }
    }
}