| 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 |
} |