mev 0.1.0

Metal Et Vulkan abstraction
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

use std::{
    mem::size_of,
    sync::{Arc, Weak},
};

use ash::vk;

use crate::generic::{ArgumentKind, Automatic, SamplerDesc};

use super::{
    arguments::ArgumentsField,
    device::{DeviceOwned, WeakDevice},
    refs::Refs,
};

struct Inner {
    owner: WeakDevice,
    desc: SamplerDesc,
}

#[derive(Clone)]
pub(super) struct WeakSampler {
    handle: vk::Sampler,
    inner: Weak<Inner>,
}

impl WeakSampler {
    #[inline]
    pub(super) fn upgrade(&self) -> Option<Sampler> {
        let inner = self.inner.upgrade()?;
        Some(Sampler {
            handle: self.handle,
            inner,
        })
    }

    #[inline]
    pub(super) fn unused(&self) -> bool {
        self.inner.strong_count() == 0
    }

    #[inline]
    pub(super) fn handle(&self) -> vk::Sampler {
        self.handle
    }
}

#[derive(Clone)]
pub struct Sampler {
    handle: vk::Sampler,
    inner: Arc<Inner>,
}

impl Drop for Inner {
    fn drop(&mut self) {
        self.owner.drop_sampler(self.desc);
    }
}

impl DeviceOwned for Sampler {
    #[inline]
    fn owner(&self) -> &WeakDevice {
        &self.inner.owner
    }
}

impl Sampler {
    #[inline]
    pub(super) fn new(owner: WeakDevice, handle: vk::Sampler, desc: SamplerDesc) -> Self {
        Sampler {
            handle,
            inner: Arc::new(Inner { owner, desc }),
        }
    }

    /// Creates a null/invalid Sampler for use when device OOM occurs.
    pub(super) fn null() -> Self {
        Sampler {
            handle: vk::Sampler::null(),
            inner: Arc::new(Inner {
                owner: WeakDevice::null(),
                desc: SamplerDesc::default(),
            }),
        }
    }

    #[inline]
    pub(super) fn downgrade(&self) -> WeakSampler {
        WeakSampler {
            handle: self.handle,
            inner: Arc::downgrade(&self.inner),
        }
    }

    #[inline]
    pub(super) fn handle(&self) -> vk::Sampler {
        self.handle
    }
}

impl ArgumentsField<Automatic> for Sampler {
    const KIND: ArgumentKind = ArgumentKind::Sampler;
    const SIZE: usize = 1;
    const OFFSET: usize = 0;
    const STRIDE: usize = size_of::<vk::DescriptorImageInfo>();

    type Update = vk::DescriptorImageInfo;

    #[inline]
    fn update(&self) -> vk::DescriptorImageInfo {
        vk::DescriptorImageInfo {
            sampler: self.handle,
            image_view: vk::ImageView::null(),
            image_layout: vk::ImageLayout::UNDEFINED,
        }
    }

    #[inline]
    fn add_refs(&self, refs: &mut Refs) {
        refs.add_sampler(self.clone());
    }
}