Debian Codegraph @

third_party/rust/wgpu-core/src/device/bgl.rs

raw
1 use core::hash::{Hash, Hasher};
2
3 use crate::{
4 binding_model::{self},
5 FastIndexMap,
6 };
7
8 /// Where a given BGL came from.
9 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
10 pub enum Origin {
11 /// The bind group layout was created by the user and is present in the BGL resource pool.
12 Pool,
13 /// The bind group layout was derived and is not present in the BGL resource pool.
14 Derived,
15 }
16
17 /// A HashMap-like structure that stores a BindGroupLayouts [`wgt::BindGroupLayoutEntry`]s.
18 ///
19 /// It is hashable, so bind group layouts can be deduplicated.
20 #[derive(Debug, Default, Clone, Eq)]
21 pub struct EntryMap {
22 /// We use a IndexMap here so that we can sort the entries by their binding index,
23 /// guaranteeing that the hash of equivalent layouts will be the same.
24 inner: FastIndexMap<u32, wgt::BindGroupLayoutEntry>,
25 /// We keep track of whether the map is sorted or not, so that we can assert that
26 /// it is sorted, so that PartialEq and Hash will be stable.
27 ///
28 /// We only need sorted if it is used in a Hash or PartialEq, so we never need
29 /// to actively sort it.
30 sorted: bool,
31 }
32
33 impl PartialEq for EntryMap {
34 fn eq(&self, other: &Self) -> bool {
35 self.assert_sorted();
36 other.assert_sorted();
37
38 self.inner == other.inner
39 }
40 }
41
42 impl Hash for EntryMap {
43 fn hash<H: Hasher>(&self, state: &mut H) {
44 self.assert_sorted();
45
46 // We don't need to hash the keys, since they are just extracted from the values.
47 //
48 // We know this is stable and will match the behavior of PartialEq as we ensure
49 // that the array is sorted.
50 for entry in self.inner.values() {
51 entry.hash(state);
52 }
53 }
54 }
55
56 impl EntryMap {
57 fn assert_sorted(&self) {
58 assert!(self.sorted);
59 }
60
61 /// Create a new [`EntryMap`] from a slice of [`wgt::BindGroupLayoutEntry`]s.
62 ///
63 /// Errors if there are duplicate bindings or if any binding index is greater than
64 /// the device's limits.
65 pub fn from_entries(
66 device_limits: &wgt::Limits,
67 entries: &[wgt::BindGroupLayoutEntry],
68 ) -> Result<Self, binding_model::CreateBindGroupLayoutError> {
69 let mut inner = FastIndexMap::with_capacity_and_hasher(entries.len(), Default::default());
70 for entry in entries {
71 if entry.binding >= device_limits.max_bindings_per_bind_group {
72 return Err(
73 binding_model::CreateBindGroupLayoutError::InvalidBindingIndex {
74 binding: entry.binding,
75 maximum: device_limits.max_bindings_per_bind_group,
76 },
77 );
78 }
79 if inner.insert(entry.binding, *entry).is_some() {
80 return Err(binding_model::CreateBindGroupLayoutError::ConflictBinding(
81 entry.binding,
82 ));
83 }
84 }
85 inner.sort_unstable_keys();
86
87 Ok(Self {
88 inner,
89 sorted: true,
90 })
91 }
92
93 /// Get the count of [`wgt::BindGroupLayoutEntry`]s in this map.
94 pub fn len(&self) -> usize {
95 self.inner.len()
96 }
97
98 /// Get the [`wgt::BindGroupLayoutEntry`] for the given binding index.
99 pub fn get(&self, binding: u32) -> Option<&wgt::BindGroupLayoutEntry> {
100 self.inner.get(&binding)
101 }
102
103 /// Iterator over all the binding indices in this map.
104 pub fn indices(&self) -> impl ExactSizeIterator<Item = u32> + '_ {
105 self.inner.keys().copied()
106 }
107
108 /// Iterator over all the [`wgt::BindGroupLayoutEntry`]s in this map.
109 pub fn values(&self) -> impl ExactSizeIterator<Item = &wgt::BindGroupLayoutEntry> + '_ {
110 self.inner.values()
111 }
112
113 pub fn iter(&self) -> impl ExactSizeIterator<Item = (&u32, &wgt::BindGroupLayoutEntry)> + '_ {
114 self.inner.iter()
115 }
116
117 pub fn is_empty(&self) -> bool {
118 self.inner.is_empty()
119 }
120
121 pub fn contains_key(&self, key: u32) -> bool {
122 self.inner.contains_key(&key)
123 }
124
125 pub fn entry(&mut self, key: u32) -> indexmap::map::Entry<'_, u32, wgt::BindGroupLayoutEntry> {
126 self.sorted = false;
127 self.inner.entry(key)
128 }
129
130 pub fn sort(&mut self) {
131 self.inner.sort_unstable_keys();
132 self.sorted = true;
133 }
134 }