ggez 0.9.3

A lightweight game framework for making 2D games with minimum friction, inspired by Love2D.
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

use super::arc::ArcBuffer;

/// Simple buffer sub-allocation helper.
///
/// In short, the allocator is:
/// - linear: i.e., just a moving cursor into each buffer -- individual deallocations are not possible
/// - growing: When the allocator is unable to find a buffer with enough free space for an allocation, it creates a new buffer
/// - aligned: This is particularly important for uniform buffers as GPUs have a restriction on min alignment for dynamic offsets into UBOs
#[derive(Debug)]
pub struct GrowingBufferArena {
    buffers: Vec<(ArcBuffer, u64)>,
    alignment: u64,
    desc: wgpu::BufferDescriptor<'static>,
}

impl GrowingBufferArena {
    pub fn new(
        device: &wgpu::Device,
        alignment: u64,
        desc: wgpu::BufferDescriptor<'static>,
    ) -> Self {
        GrowingBufferArena {
            buffers: vec![(ArcBuffer::new(device.create_buffer(&desc)), 0)],
            alignment,
            desc,
        }
    }

    pub fn allocate(&mut self, device: &wgpu::Device, size: u64) -> ArenaAllocation {
        let size = align(self.alignment, size);
        assert!(size <= self.desc.size);

        for (buffer, cursor) in &mut self.buffers {
            if size <= self.desc.size - *cursor {
                let offset = *cursor;
                *cursor += size;
                return ArenaAllocation {
                    buffer: buffer.clone(),
                    offset,
                };
            }
        }

        self.grow(device);
        self.allocate(device, size)
    }

    /// This frees **all** the allocations at once.
    pub fn free(&mut self) {
        for (_, cursor) in &mut self.buffers {
            *cursor = 0;
        }
    }

    fn grow(&mut self, device: &wgpu::Device) {
        self.buffers
            .push((ArcBuffer::new(device.create_buffer(&self.desc)), 0));
    }
}

#[derive(Debug, Clone)]
pub struct ArenaAllocation {
    pub buffer: ArcBuffer,
    pub offset: u64,
}

fn align(alignment: u64, size: u64) -> u64 {
    (size + alignment - 1) & !(alignment - 1)
}