dynamis-gpu 0.6.0

GPU-driven physics engine
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

use wgpu::{BufferAddress, BufferUsages, Device};

#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct DispatchArgs {
    per_row: u32,
    rows: u32,
    layers: u32,
    _pad: u32,
}

pub const DISPATCH_ARGS_BYTES: BufferAddress = size_of::<DispatchArgs>() as BufferAddress;

const _: () = assert!(DISPATCH_ARGS_BYTES == 16);

pub struct DispatchTable {
    buffer: crate::GpuBuffer,
    slots: u32,
}

impl DispatchTable {
    pub fn new(device: &Device, label: &str, slots: u32) -> Self {
        assert!(slots > 0, "a dispatch table needs at least one slot");
        Self {
            buffer: crate::GpuBuffer::new(
                device,
                label,
                slots as BufferAddress * DISPATCH_ARGS_BYTES,
                BufferUsages::STORAGE
                    .union(BufferUsages::INDIRECT)
                    .union(BufferUsages::COPY_DST),
            ),
            slots,
        }
    }

    pub fn buffer(&self) -> &crate::GpuBuffer {
        &self.buffer
    }

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

    pub fn offset(&self, slot: u32) -> BufferAddress {
        assert!(
            slot < self.slots,
            "dispatch slot {slot} is outside the {} table slots",
            self.slots
        );
        slot as BufferAddress * DISPATCH_ARGS_BYTES
    }
}