erupt/generated/extensions/
ext_shader_atomic_float2.rs1#[doc(alias = "VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION")]
4pub const EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION: u32 = 1;
5#[doc(alias = "VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME")]
7pub const EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8 "VK_EXT_shader_atomic_float2"
9);
10impl crate::vk1_0::StructureType {
12 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(
13 1000273000,
14 );
15}
16impl<'a> crate::ExtendableFrom<'a, PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
17for crate::vk1_0::DeviceCreateInfoBuilder<'a> {}
18impl<
19 'a,
20> crate::ExtendableFrom<'a, PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>>
21for crate::vk1_0::DeviceCreateInfoBuilder<'a> {}
22impl<'a> crate::ExtendableFrom<'a, PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
23for crate::vk1_1::PhysicalDeviceFeatures2Builder<'a> {}
24impl<
25 'a,
26> crate::ExtendableFrom<'a, PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>>
27for crate::vk1_1::PhysicalDeviceFeatures2Builder<'a> {}
28#[doc(alias = "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT")]
30#[derive(Copy, Clone)]
31#[repr(C)]
32pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
33 pub s_type: crate::vk1_0::StructureType,
34 pub p_next: *mut std::ffi::c_void,
35 pub shader_buffer_float16_atomics: crate::vk1_0::Bool32,
36 pub shader_buffer_float16_atomic_add: crate::vk1_0::Bool32,
37 pub shader_buffer_float16_atomic_min_max: crate::vk1_0::Bool32,
38 pub shader_buffer_float32_atomic_min_max: crate::vk1_0::Bool32,
39 pub shader_buffer_float64_atomic_min_max: crate::vk1_0::Bool32,
40 pub shader_shared_float16_atomics: crate::vk1_0::Bool32,
41 pub shader_shared_float16_atomic_add: crate::vk1_0::Bool32,
42 pub shader_shared_float16_atomic_min_max: crate::vk1_0::Bool32,
43 pub shader_shared_float32_atomic_min_max: crate::vk1_0::Bool32,
44 pub shader_shared_float64_atomic_min_max: crate::vk1_0::Bool32,
45 pub shader_image_float32_atomic_min_max: crate::vk1_0::Bool32,
46 pub sparse_image_float32_atomic_min_max: crate::vk1_0::Bool32,
47}
48impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
49 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
50}
51impl Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
52 fn default() -> Self {
53 Self {
54 s_type: Self::STRUCTURE_TYPE,
55 p_next: std::ptr::null_mut(),
56 shader_buffer_float16_atomics: Default::default(),
57 shader_buffer_float16_atomic_add: Default::default(),
58 shader_buffer_float16_atomic_min_max: Default::default(),
59 shader_buffer_float32_atomic_min_max: Default::default(),
60 shader_buffer_float64_atomic_min_max: Default::default(),
61 shader_shared_float16_atomics: Default::default(),
62 shader_shared_float16_atomic_add: Default::default(),
63 shader_shared_float16_atomic_min_max: Default::default(),
64 shader_shared_float32_atomic_min_max: Default::default(),
65 shader_shared_float64_atomic_min_max: Default::default(),
66 shader_image_float32_atomic_min_max: Default::default(),
67 sparse_image_float32_atomic_min_max: Default::default(),
68 }
69 }
70}
71impl std::fmt::Debug for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
72 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
73 f.debug_struct("PhysicalDeviceShaderAtomicFloat2FeaturesEXT")
74 .field("s_type", &self.s_type)
75 .field("p_next", &self.p_next)
76 .field(
77 "shader_buffer_float16_atomics",
78 &(self.shader_buffer_float16_atomics != 0),
79 )
80 .field(
81 "shader_buffer_float16_atomic_add",
82 &(self.shader_buffer_float16_atomic_add != 0),
83 )
84 .field(
85 "shader_buffer_float16_atomic_min_max",
86 &(self.shader_buffer_float16_atomic_min_max != 0),
87 )
88 .field(
89 "shader_buffer_float32_atomic_min_max",
90 &(self.shader_buffer_float32_atomic_min_max != 0),
91 )
92 .field(
93 "shader_buffer_float64_atomic_min_max",
94 &(self.shader_buffer_float64_atomic_min_max != 0),
95 )
96 .field(
97 "shader_shared_float16_atomics",
98 &(self.shader_shared_float16_atomics != 0),
99 )
100 .field(
101 "shader_shared_float16_atomic_add",
102 &(self.shader_shared_float16_atomic_add != 0),
103 )
104 .field(
105 "shader_shared_float16_atomic_min_max",
106 &(self.shader_shared_float16_atomic_min_max != 0),
107 )
108 .field(
109 "shader_shared_float32_atomic_min_max",
110 &(self.shader_shared_float32_atomic_min_max != 0),
111 )
112 .field(
113 "shader_shared_float64_atomic_min_max",
114 &(self.shader_shared_float64_atomic_min_max != 0),
115 )
116 .field(
117 "shader_image_float32_atomic_min_max",
118 &(self.shader_image_float32_atomic_min_max != 0),
119 )
120 .field(
121 "sparse_image_float32_atomic_min_max",
122 &(self.sparse_image_float32_atomic_min_max != 0),
123 )
124 .finish()
125 }
126}
127impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
128 #[inline]
129 pub fn into_builder<'a>(
130 self,
131 ) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
132 PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder(
133 self,
134 std::marker::PhantomData,
135 )
136 }
137}
138#[derive(Copy, Clone)]
139#[repr(transparent)]
141pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a>(
142 PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
143 std::marker::PhantomData<&'a ()>,
144);
145impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
146 #[inline]
147 pub fn new() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
148 PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder(
149 Default::default(),
150 std::marker::PhantomData,
151 )
152 }
153 #[inline]
154 #[must_use]
155 pub fn shader_buffer_float16_atomics(
156 mut self,
157 shader_buffer_float16_atomics: bool,
158 ) -> Self {
159 self.0.shader_buffer_float16_atomics = shader_buffer_float16_atomics as _;
160 self
161 }
162 #[inline]
163 #[must_use]
164 pub fn shader_buffer_float16_atomic_add(
165 mut self,
166 shader_buffer_float16_atomic_add: bool,
167 ) -> Self {
168 self.0.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add as _;
169 self
170 }
171 #[inline]
172 #[must_use]
173 pub fn shader_buffer_float16_atomic_min_max(
174 mut self,
175 shader_buffer_float16_atomic_min_max: bool,
176 ) -> Self {
177 self
178 .0
179 .shader_buffer_float16_atomic_min_max = shader_buffer_float16_atomic_min_max
180 as _;
181 self
182 }
183 #[inline]
184 #[must_use]
185 pub fn shader_buffer_float32_atomic_min_max(
186 mut self,
187 shader_buffer_float32_atomic_min_max: bool,
188 ) -> Self {
189 self
190 .0
191 .shader_buffer_float32_atomic_min_max = shader_buffer_float32_atomic_min_max
192 as _;
193 self
194 }
195 #[inline]
196 #[must_use]
197 pub fn shader_buffer_float64_atomic_min_max(
198 mut self,
199 shader_buffer_float64_atomic_min_max: bool,
200 ) -> Self {
201 self
202 .0
203 .shader_buffer_float64_atomic_min_max = shader_buffer_float64_atomic_min_max
204 as _;
205 self
206 }
207 #[inline]
208 #[must_use]
209 pub fn shader_shared_float16_atomics(
210 mut self,
211 shader_shared_float16_atomics: bool,
212 ) -> Self {
213 self.0.shader_shared_float16_atomics = shader_shared_float16_atomics as _;
214 self
215 }
216 #[inline]
217 #[must_use]
218 pub fn shader_shared_float16_atomic_add(
219 mut self,
220 shader_shared_float16_atomic_add: bool,
221 ) -> Self {
222 self.0.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add as _;
223 self
224 }
225 #[inline]
226 #[must_use]
227 pub fn shader_shared_float16_atomic_min_max(
228 mut self,
229 shader_shared_float16_atomic_min_max: bool,
230 ) -> Self {
231 self
232 .0
233 .shader_shared_float16_atomic_min_max = shader_shared_float16_atomic_min_max
234 as _;
235 self
236 }
237 #[inline]
238 #[must_use]
239 pub fn shader_shared_float32_atomic_min_max(
240 mut self,
241 shader_shared_float32_atomic_min_max: bool,
242 ) -> Self {
243 self
244 .0
245 .shader_shared_float32_atomic_min_max = shader_shared_float32_atomic_min_max
246 as _;
247 self
248 }
249 #[inline]
250 #[must_use]
251 pub fn shader_shared_float64_atomic_min_max(
252 mut self,
253 shader_shared_float64_atomic_min_max: bool,
254 ) -> Self {
255 self
256 .0
257 .shader_shared_float64_atomic_min_max = shader_shared_float64_atomic_min_max
258 as _;
259 self
260 }
261 #[inline]
262 #[must_use]
263 pub fn shader_image_float32_atomic_min_max(
264 mut self,
265 shader_image_float32_atomic_min_max: bool,
266 ) -> Self {
267 self
268 .0
269 .shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max
270 as _;
271 self
272 }
273 #[inline]
274 #[must_use]
275 pub fn sparse_image_float32_atomic_min_max(
276 mut self,
277 sparse_image_float32_atomic_min_max: bool,
278 ) -> Self {
279 self
280 .0
281 .sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max
282 as _;
283 self
284 }
285 #[inline]
286 pub fn build_dangling(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
289 self.0
290 }
291}
292impl<'a> std::default::Default
293for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
294 fn default() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
295 Self::new()
296 }
297}
298impl<'a> std::fmt::Debug for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
299 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
300 std::fmt::Debug::fmt(&self.0, f)
301 }
302}
303impl<'a> std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
304 type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
305 fn deref(&self) -> &Self::Target {
306 &self.0
307 }
308}
309impl<'a> std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
310 fn deref_mut(&mut self) -> &mut Self::Target {
311 &mut self.0
312 }
313}