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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
//! Generational and registry handles for GPU content.
//!
//! The handle machinery ([`ContentHandle`], [`slot_handle!`],
//! [`registry_handle!`]) lives here; the individual handle types are defined in
//! the domain submodules and re-exported.
//!
//! Most GPU content the renderer stores (meshes, textures, splat sets, volumes,
//! curves) is keyed by a handle into a slotted store. A removed entry leaves an
//! empty slot that a later insert reuses; the handle carries the generation its
//! slot had when it was issued, and the store bumps that generation on removal.
//! A stale handle then resolves to nothing rather than aliasing whatever now
//! occupies the slot.
//!
//! [`slot_handle!`] generates one of these handle types with the standard
//! surface (an `INVALID` sentinel, `index`, and a private `new`), so every
//! content handle looks and behaves the same. [`ContentHandle`] is the common
//! interface over them. [`registry_handle!`] generates the append-only variant
//! for resources that are created once and never freed, so they need no
//! generation.
/// Common interface implemented by every slotted content handle.
///
/// Lets code that does not care which resource a handle names (residency
/// accounting, generic validity checks) work over any of them.
/// Define a generational handle newtype with the standard surface.
///
/// Generates a `{ index: u32, generation: u32 }` struct plus its `INVALID`
/// sentinel, `index`, crate-internal `new`, and a [`ContentHandle`] impl. Pass
/// the doc comment and visibility; the derives and methods are fixed so every
/// handle matches.
;
/// The raw slot index this handle points at. Used to index parallel
/// per-slot arrays; not meaningful for [`INVALID`](Self::INVALID).
/// The generation this handle was issued against. Paired with
/// [`index`](Self::index) it identifies a specific slot occupancy;
/// a lookup fails once the slot's generation moves past it.
/// Build a handle from raw parts. Crate-internal: outside code
/// obtains a handle from an upload call and treats it as opaque.
pub
/// Fabricate a handle naming raw slot `index` at generation 0, the
/// generation a freshly inserted slot carries.
///
/// Hidden from the documented surface: production code obtains
/// handles from upload calls and treats them as opaque. This exists
/// for tests, benches, and fixtures that need to name a slot
/// directly (or synthesize a deliberately out-of-range id).
}
};
}
/// Define an append-only registry handle: a stable index into a grow-only store
/// that never frees or reuses slots, so it needs no generation.
///
/// These name resources created once and kept for the session (density volumes,
/// projected-tet meshes, GPU particle systems). The handle is opaque: it is
/// obtained from a create / upload call, and its inner index is crate-private so
/// it cannot be synthesised by hand. If a resource class later becomes
/// evictable, its handle graduates to [`slot_handle!`] and gains a generation;
/// because it is already opaque, that is an additive change for consumers.
pub use EnvironmentMapId;
pub use ;
pub use MatcapId;
pub use ;
pub use PickId;
pub use GaussianSplatId;
pub use TextureId;
pub use ;