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