1#![allow(
9 non_camel_case_types,
10 non_snake_case,
11 clippy::bad_bit_mask,
12 clippy::let_unit_value,
13 clippy::missing_safety_doc,
14 clippy::missing_transmute_annotations,
15 clippy::needless_lifetimes,
16 clippy::too_many_arguments,
17 clippy::type_complexity,
18 clippy::unnecessary_cast,
19 clippy::upper_case_acronyms,
20 clippy::useless_transmute
21)]
22
23use core::ffi::{c_char, c_void};
24use core::fmt;
25use core::mem::MaybeUninit;
26
27use crate::*;
28
29#[repr(C)]
31#[derive(Copy, Clone)]
32pub union AccelerationStructureGeometryDataKHR {
33 pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
34 pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
35 pub instances: AccelerationStructureGeometryInstancesDataKHR,
36}
37
38impl Default for AccelerationStructureGeometryDataKHR {
39 #[inline]
40 fn default() -> Self {
41 unsafe { MaybeUninit::zeroed().assume_init() }
42 }
43}
44
45impl fmt::Debug for AccelerationStructureGeometryDataKHR {
46 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
47 write!(f, "AccelerationStructureGeometryDataKHR")
48 }
49}
50
51#[repr(C)]
53#[derive(Copy, Clone)]
54pub union AccelerationStructureMotionInstanceDataNV {
55 pub static_instance: AccelerationStructureInstanceKHR,
56 pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
57 pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
58}
59
60impl Default for AccelerationStructureMotionInstanceDataNV {
61 #[inline]
62 fn default() -> Self {
63 unsafe { MaybeUninit::zeroed().assume_init() }
64 }
65}
66
67impl fmt::Debug for AccelerationStructureMotionInstanceDataNV {
68 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
69 write!(f, "AccelerationStructureMotionInstanceDataNV")
70 }
71}
72
73#[repr(C)]
75#[derive(Copy, Clone)]
76pub union ClearColorValue {
77 pub float32: [f32; 4],
78 pub int32: [i32; 4],
79 pub uint32: [u32; 4],
80}
81
82impl Default for ClearColorValue {
83 #[inline]
84 fn default() -> Self {
85 unsafe { MaybeUninit::zeroed().assume_init() }
86 }
87}
88
89impl fmt::Debug for ClearColorValue {
90 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
91 write!(f, "ClearColorValue")
92 }
93}
94
95#[repr(C)]
97#[derive(Copy, Clone)]
98pub union ClearValue {
99 pub color: ClearColorValue,
100 pub depth_stencil: ClearDepthStencilValue,
101}
102
103impl Default for ClearValue {
104 #[inline]
105 fn default() -> Self {
106 unsafe { MaybeUninit::zeroed().assume_init() }
107 }
108}
109
110impl fmt::Debug for ClearValue {
111 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
112 write!(f, "ClearValue")
113 }
114}
115
116#[repr(C)]
118#[derive(Copy, Clone)]
119pub union ClusterAccelerationStructureOpInputNV {
120 pub clusters_bottom_level: *mut ClusterAccelerationStructureClustersBottomLevelInputNV,
121 pub triangle_clusters: *mut ClusterAccelerationStructureTriangleClusterInputNV,
122 pub move_objects: *mut ClusterAccelerationStructureMoveObjectsInputNV,
123}
124
125impl Default for ClusterAccelerationStructureOpInputNV {
126 #[inline]
127 fn default() -> Self {
128 unsafe { MaybeUninit::zeroed().assume_init() }
129 }
130}
131
132impl fmt::Debug for ClusterAccelerationStructureOpInputNV {
133 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
134 write!(f, "ClusterAccelerationStructureOpInputNV")
135 }
136}
137
138#[repr(C)]
140#[derive(Copy, Clone)]
141pub union DescriptorDataEXT {
142 pub sampler: *const Sampler,
143 pub combined_image_sampler: *const DescriptorImageInfo,
144 pub input_attachment_image: *const DescriptorImageInfo,
145 pub sampled_image: *const DescriptorImageInfo,
146 pub storage_image: *const DescriptorImageInfo,
147 pub uniform_texel_buffer: *const DescriptorAddressInfoEXT,
148 pub storage_texel_buffer: *const DescriptorAddressInfoEXT,
149 pub uniform_buffer: *const DescriptorAddressInfoEXT,
150 pub storage_buffer: *const DescriptorAddressInfoEXT,
151 pub acceleration_structure: DeviceAddress,
152}
153
154impl Default for DescriptorDataEXT {
155 #[inline]
156 fn default() -> Self {
157 unsafe { MaybeUninit::zeroed().assume_init() }
158 }
159}
160
161impl fmt::Debug for DescriptorDataEXT {
162 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
163 write!(f, "DescriptorDataEXT")
164 }
165}
166
167#[repr(C)]
169#[derive(Copy, Clone)]
170pub union DeviceOrHostAddressConstAMDX {
171 pub device_address: DeviceAddress,
172 pub host_address: *const c_void,
173}
174
175impl Default for DeviceOrHostAddressConstAMDX {
176 #[inline]
177 fn default() -> Self {
178 unsafe { MaybeUninit::zeroed().assume_init() }
179 }
180}
181
182impl fmt::Debug for DeviceOrHostAddressConstAMDX {
183 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
184 write!(f, "DeviceOrHostAddressConstAMDX")
185 }
186}
187
188#[repr(C)]
190#[derive(Copy, Clone)]
191pub union DeviceOrHostAddressConstKHR {
192 pub device_address: DeviceAddress,
193 pub host_address: *const c_void,
194}
195
196impl Default for DeviceOrHostAddressConstKHR {
197 #[inline]
198 fn default() -> Self {
199 unsafe { MaybeUninit::zeroed().assume_init() }
200 }
201}
202
203impl fmt::Debug for DeviceOrHostAddressConstKHR {
204 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
205 write!(f, "DeviceOrHostAddressConstKHR")
206 }
207}
208
209#[repr(C)]
211#[derive(Copy, Clone)]
212pub union DeviceOrHostAddressKHR {
213 pub device_address: DeviceAddress,
214 pub host_address: *mut c_void,
215}
216
217impl Default for DeviceOrHostAddressKHR {
218 #[inline]
219 fn default() -> Self {
220 unsafe { MaybeUninit::zeroed().assume_init() }
221 }
222}
223
224impl fmt::Debug for DeviceOrHostAddressKHR {
225 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
226 write!(f, "DeviceOrHostAddressKHR")
227 }
228}
229
230#[repr(C)]
232#[derive(Copy, Clone)]
233pub union IndirectCommandsTokenDataEXT {
234 pub push_constant: *const IndirectCommandsPushConstantTokenEXT,
235 pub vertex_buffer: *const IndirectCommandsVertexBufferTokenEXT,
236 pub index_buffer: *const IndirectCommandsIndexBufferTokenEXT,
237 pub execution_set: *const IndirectCommandsExecutionSetTokenEXT,
238}
239
240impl Default for IndirectCommandsTokenDataEXT {
241 #[inline]
242 fn default() -> Self {
243 unsafe { MaybeUninit::zeroed().assume_init() }
244 }
245}
246
247impl fmt::Debug for IndirectCommandsTokenDataEXT {
248 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
249 write!(f, "IndirectCommandsTokenDataEXT")
250 }
251}
252
253#[repr(C)]
255#[derive(Copy, Clone)]
256pub union IndirectExecutionSetInfoEXT {
257 pub pipeline_info: *const IndirectExecutionSetPipelineInfoEXT,
258 pub shader_info: *const IndirectExecutionSetShaderInfoEXT,
259}
260
261impl Default for IndirectExecutionSetInfoEXT {
262 #[inline]
263 fn default() -> Self {
264 unsafe { MaybeUninit::zeroed().assume_init() }
265 }
266}
267
268impl fmt::Debug for IndirectExecutionSetInfoEXT {
269 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
270 write!(f, "IndirectExecutionSetInfoEXT")
271 }
272}
273
274#[repr(C)]
276#[derive(Copy, Clone)]
277pub union PerformanceCounterResultKHR {
278 pub int32: i32,
279 pub int64: i64,
280 pub uint32: u32,
281 pub uint64: u64,
282 pub float32: f32,
283 pub float64: f64,
284}
285
286impl Default for PerformanceCounterResultKHR {
287 #[inline]
288 fn default() -> Self {
289 unsafe { MaybeUninit::zeroed().assume_init() }
290 }
291}
292
293impl fmt::Debug for PerformanceCounterResultKHR {
294 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
295 write!(f, "PerformanceCounterResultKHR")
296 }
297}
298
299#[repr(C)]
301#[derive(Copy, Clone)]
302pub union PerformanceValueDataINTEL {
303 pub value32: u32,
304 pub value64: u64,
305 pub value_float: f32,
306 pub value_bool: Bool32,
307 pub value_string: *const c_char,
308}
309
310impl Default for PerformanceValueDataINTEL {
311 #[inline]
312 fn default() -> Self {
313 unsafe { MaybeUninit::zeroed().assume_init() }
314 }
315}
316
317impl fmt::Debug for PerformanceValueDataINTEL {
318 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
319 write!(f, "PerformanceValueDataINTEL")
320 }
321}
322
323#[repr(C)]
325#[derive(Copy, Clone)]
326pub union PipelineExecutableStatisticValueKHR {
327 pub b32: Bool32,
328 pub i64: i64,
329 pub u64: u64,
330 pub f64: f64,
331}
332
333impl Default for PipelineExecutableStatisticValueKHR {
334 #[inline]
335 fn default() -> Self {
336 unsafe { MaybeUninit::zeroed().assume_init() }
337 }
338}
339
340impl fmt::Debug for PipelineExecutableStatisticValueKHR {
341 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
342 write!(f, "PipelineExecutableStatisticValueKHR")
343 }
344}