dynamis-gpu 0.7.0

wgpu device, buffer, stream, pipeline, and readback runtime
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

use crate::{GpuSlot, StreamElement, TypedSlot};

const DOMAIN_SHIFT: u32 = 24;
const LOCAL_MASK: u32 = (1 << DOMAIN_SHIFT) - 1;

#[derive(Clone, Copy, PartialEq, Eq)]
pub struct ResourceId(u32);

impl ResourceId {
    pub const fn new(domain: u32, local: u32) -> Self {
        assert!(domain < (1 << (32 - DOMAIN_SHIFT)));
        assert!(local < (1 << DOMAIN_SHIFT));
        Self((domain << DOMAIN_SHIFT) | local)
    }

    pub const fn domain(self) -> u32 {
        self.0 >> DOMAIN_SHIFT
    }

    pub const fn local(self) -> u32 {
        self.0 & LOCAL_MASK
    }
}

#[derive(Clone, Copy)]
pub enum SlotRef {
    Whole {
        resource: ResourceId,
        element: StreamElement,
    },
    Range {
        resource: ResourceId,
        offset: u64,
        size: u64,
        element: StreamElement,
    },
}

impl SlotRef {
    pub const fn whole(resource: ResourceId, element: StreamElement) -> Self {
        Self::Whole { resource, element }
    }

    pub const fn range(
        resource: ResourceId,
        offset: u64,
        size: u64,
        element: StreamElement,
    ) -> Self {
        Self::Range {
            resource,
            offset,
            size,
            element,
        }
    }

    pub const fn element(self) -> StreamElement {
        match self {
            Self::Whole { element, .. } | Self::Range { element, .. } => element,
        }
    }

    pub fn resolve<R: Resources>(self, resources: &R) -> TypedSlot<'_> {
        match self {
            Self::Whole { resource, .. } => {
                TypedSlot::new(resources.whole(resource), self.element())
            }
            Self::Range {
                resource,
                offset,
                size,
                ..
            } => TypedSlot::new(resources.range(resource, offset, size), self.element()),
        }
    }
}

pub trait Resources {
    fn generation(&self) -> u64;

    fn slots(&self, resource: ResourceId) -> u32;

    fn whole(&self, resource: ResourceId) -> GpuSlot<'_>;

    fn range(&self, resource: ResourceId, offset: u64, size: u64) -> GpuSlot<'_>;
}