1#![allow(unused_imports)]
2use crate::vk::*;
3use core::ffi::*;
4#[doc = "Extensions tagged AMD"]
5pub mod amd {
6 #[doc = "VK_AMD_rasterization_order"]
7 pub mod rasterization_order {
8 use super::super::*;
9 pub use {
10 crate::vk::AMD_RASTERIZATION_ORDER_NAME as NAME,
11 crate::vk::AMD_RASTERIZATION_ORDER_SPEC_VERSION as SPEC_VERSION,
12 };
13 }
14 #[doc = "VK_AMD_shader_trinary_minmax"]
15 pub mod shader_trinary_minmax {
16 use super::super::*;
17 pub use {
18 crate::vk::AMD_SHADER_TRINARY_MINMAX_NAME as NAME,
19 crate::vk::AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION as SPEC_VERSION,
20 };
21 }
22 #[doc = "VK_AMD_shader_explicit_vertex_parameter"]
23 pub mod shader_explicit_vertex_parameter {
24 use super::super::*;
25 pub use {
26 crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_NAME as NAME,
27 crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION as SPEC_VERSION,
28 };
29 }
30 #[doc = "VK_AMD_gcn_shader"]
31 pub mod gcn_shader {
32 use super::super::*;
33 pub use {
34 crate::vk::AMD_GCN_SHADER_NAME as NAME,
35 crate::vk::AMD_GCN_SHADER_SPEC_VERSION as SPEC_VERSION,
36 };
37 }
38 #[doc = "VK_AMD_draw_indirect_count"]
39 pub mod draw_indirect_count {
40 use super::super::*;
41 pub use {
42 crate::vk::AMD_DRAW_INDIRECT_COUNT_NAME as NAME,
43 crate::vk::AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION as SPEC_VERSION,
44 };
45 #[doc = "VK_AMD_draw_indirect_count device-level functions"]
46 #[derive(Clone)]
47 pub struct Device {
48 pub(crate) fp: DeviceFn,
49 pub(crate) handle: crate::vk::Device,
50 }
51 impl Device {
52 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
53 let handle = device.handle();
54 let fp = DeviceFn::load(|name| unsafe {
55 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
56 });
57 Self { handle, fp }
58 }
59 #[inline]
60 pub fn fp(&self) -> &DeviceFn {
61 &self.fp
62 }
63 #[inline]
64 pub fn device(&self) -> crate::vk::Device {
65 self.handle
66 }
67 }
68 #[derive(Clone)]
69 #[doc = "Raw VK_AMD_draw_indirect_count device-level function pointers"]
70 pub struct DeviceFn {
71 pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount,
72 pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount,
73 }
74 unsafe impl Send for DeviceFn {}
75 unsafe impl Sync for DeviceFn {}
76 impl DeviceFn {
77 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
78 Self::load_erased(&mut f)
79 }
80 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
81 Self {
82 cmd_draw_indirect_count_amd: unsafe {
83 unsafe extern "system" fn cmd_draw_indirect_count_amd(
84 _command_buffer: CommandBuffer,
85 _buffer: Buffer,
86 _offset: DeviceSize,
87 _count_buffer: Buffer,
88 _count_buffer_offset: DeviceSize,
89 _max_draw_count: u32,
90 _stride: u32,
91 ) {
92 panic!(concat!(
93 "Unable to load ",
94 stringify!(cmd_draw_indirect_count_amd)
95 ))
96 }
97 let cname =
98 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0");
99 let val = _f(cname);
100 if val.is_null() {
101 cmd_draw_indirect_count_amd
102 } else {
103 ::core::mem::transmute(val)
104 }
105 },
106 cmd_draw_indexed_indirect_count_amd: unsafe {
107 unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd(
108 _command_buffer: CommandBuffer,
109 _buffer: Buffer,
110 _offset: DeviceSize,
111 _count_buffer: Buffer,
112 _count_buffer_offset: DeviceSize,
113 _max_draw_count: u32,
114 _stride: u32,
115 ) {
116 panic!(concat!(
117 "Unable to load ",
118 stringify!(cmd_draw_indexed_indirect_count_amd)
119 ))
120 }
121 let cname = CStr::from_bytes_with_nul_unchecked(
122 b"vkCmdDrawIndexedIndirectCountAMD\0",
123 );
124 let val = _f(cname);
125 if val.is_null() {
126 cmd_draw_indexed_indirect_count_amd
127 } else {
128 ::core::mem::transmute(val)
129 }
130 },
131 }
132 }
133 }
134 }
135 #[doc = "VK_AMD_negative_viewport_height"]
136 pub mod negative_viewport_height {
137 use super::super::*;
138 pub use {
139 crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_NAME as NAME,
140 crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION as SPEC_VERSION,
141 };
142 }
143 #[doc = "VK_AMD_gpu_shader_half_float"]
144 pub mod gpu_shader_half_float {
145 use super::super::*;
146 pub use {
147 crate::vk::AMD_GPU_SHADER_HALF_FLOAT_NAME as NAME,
148 crate::vk::AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION as SPEC_VERSION,
149 };
150 }
151 #[doc = "VK_AMD_shader_ballot"]
152 pub mod shader_ballot {
153 use super::super::*;
154 pub use {
155 crate::vk::AMD_SHADER_BALLOT_NAME as NAME,
156 crate::vk::AMD_SHADER_BALLOT_SPEC_VERSION as SPEC_VERSION,
157 };
158 }
159 #[doc = "VK_AMD_texture_gather_bias_lod"]
160 pub mod texture_gather_bias_lod {
161 use super::super::*;
162 pub use {
163 crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_NAME as NAME,
164 crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION as SPEC_VERSION,
165 };
166 }
167 #[doc = "VK_AMD_shader_info"]
168 pub mod shader_info {
169 use super::super::*;
170 pub use {
171 crate::vk::AMD_SHADER_INFO_NAME as NAME,
172 crate::vk::AMD_SHADER_INFO_SPEC_VERSION as SPEC_VERSION,
173 };
174 #[doc = "VK_AMD_shader_info device-level functions"]
175 #[derive(Clone)]
176 pub struct Device {
177 pub(crate) fp: DeviceFn,
178 pub(crate) handle: crate::vk::Device,
179 }
180 impl Device {
181 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
182 let handle = device.handle();
183 let fp = DeviceFn::load(|name| unsafe {
184 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
185 });
186 Self { handle, fp }
187 }
188 #[inline]
189 pub fn fp(&self) -> &DeviceFn {
190 &self.fp
191 }
192 #[inline]
193 pub fn device(&self) -> crate::vk::Device {
194 self.handle
195 }
196 }
197 #[derive(Clone)]
198 #[doc = "Raw VK_AMD_shader_info device-level function pointers"]
199 pub struct DeviceFn {
200 pub get_shader_info_amd: PFN_vkGetShaderInfoAMD,
201 }
202 unsafe impl Send for DeviceFn {}
203 unsafe impl Sync for DeviceFn {}
204 impl DeviceFn {
205 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
206 Self::load_erased(&mut f)
207 }
208 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
209 Self {
210 get_shader_info_amd: unsafe {
211 unsafe extern "system" fn get_shader_info_amd(
212 _device: crate::vk::Device,
213 _pipeline: Pipeline,
214 _shader_stage: ShaderStageFlags,
215 _info_type: ShaderInfoTypeAMD,
216 _p_info_size: *mut usize,
217 _p_info: *mut c_void,
218 ) -> Result {
219 panic!(concat!("Unable to load ", stringify!(get_shader_info_amd)))
220 }
221 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0");
222 let val = _f(cname);
223 if val.is_null() {
224 get_shader_info_amd
225 } else {
226 ::core::mem::transmute(val)
227 }
228 },
229 }
230 }
231 }
232 }
233 #[doc = "VK_AMD_shader_image_load_store_lod"]
234 pub mod shader_image_load_store_lod {
235 use super::super::*;
236 pub use {
237 crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_NAME as NAME,
238 crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION as SPEC_VERSION,
239 };
240 }
241 #[doc = "VK_AMD_gpu_shader_int16"]
242 pub mod gpu_shader_int16 {
243 use super::super::*;
244 pub use {
245 crate::vk::AMD_GPU_SHADER_INT16_NAME as NAME,
246 crate::vk::AMD_GPU_SHADER_INT16_SPEC_VERSION as SPEC_VERSION,
247 };
248 }
249 #[doc = "VK_AMD_mixed_attachment_samples"]
250 pub mod mixed_attachment_samples {
251 use super::super::*;
252 pub use {
253 crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_NAME as NAME,
254 crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION as SPEC_VERSION,
255 };
256 }
257 #[doc = "VK_AMD_shader_fragment_mask"]
258 pub mod shader_fragment_mask {
259 use super::super::*;
260 pub use {
261 crate::vk::AMD_SHADER_FRAGMENT_MASK_NAME as NAME,
262 crate::vk::AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION as SPEC_VERSION,
263 };
264 }
265 #[doc = "VK_AMD_buffer_marker"]
266 pub mod buffer_marker {
267 use super::super::*;
268 pub use {
269 crate::vk::AMD_BUFFER_MARKER_NAME as NAME,
270 crate::vk::AMD_BUFFER_MARKER_SPEC_VERSION as SPEC_VERSION,
271 };
272 #[doc = "VK_AMD_buffer_marker device-level functions"]
273 #[derive(Clone)]
274 pub struct Device {
275 pub(crate) fp: DeviceFn,
276 pub(crate) handle: crate::vk::Device,
277 }
278 impl Device {
279 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
280 let handle = device.handle();
281 let fp = DeviceFn::load(|name| unsafe {
282 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
283 });
284 Self { handle, fp }
285 }
286 #[inline]
287 pub fn fp(&self) -> &DeviceFn {
288 &self.fp
289 }
290 #[inline]
291 pub fn device(&self) -> crate::vk::Device {
292 self.handle
293 }
294 }
295 #[derive(Clone)]
296 #[doc = "Raw VK_AMD_buffer_marker device-level function pointers"]
297 pub struct DeviceFn {
298 pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD,
299 }
300 unsafe impl Send for DeviceFn {}
301 unsafe impl Sync for DeviceFn {}
302 impl DeviceFn {
303 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
304 Self::load_erased(&mut f)
305 }
306 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
307 Self {
308 cmd_write_buffer_marker_amd: unsafe {
309 unsafe extern "system" fn cmd_write_buffer_marker_amd(
310 _command_buffer: CommandBuffer,
311 _pipeline_stage: PipelineStageFlags,
312 _dst_buffer: Buffer,
313 _dst_offset: DeviceSize,
314 _marker: u32,
315 ) {
316 panic!(concat!(
317 "Unable to load ",
318 stringify!(cmd_write_buffer_marker_amd)
319 ))
320 }
321 let cname =
322 CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0");
323 let val = _f(cname);
324 if val.is_null() {
325 cmd_write_buffer_marker_amd
326 } else {
327 ::core::mem::transmute(val)
328 }
329 },
330 }
331 }
332 }
333 }
334 #[doc = "VK_AMD_pipeline_compiler_control"]
335 pub mod pipeline_compiler_control {
336 use super::super::*;
337 pub use {
338 crate::vk::AMD_PIPELINE_COMPILER_CONTROL_NAME as NAME,
339 crate::vk::AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION as SPEC_VERSION,
340 };
341 }
342 #[doc = "VK_AMD_shader_core_properties"]
343 pub mod shader_core_properties {
344 use super::super::*;
345 pub use {
346 crate::vk::AMD_SHADER_CORE_PROPERTIES_NAME as NAME,
347 crate::vk::AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
348 };
349 }
350 #[doc = "VK_AMD_memory_overallocation_behavior"]
351 pub mod memory_overallocation_behavior {
352 use super::super::*;
353 pub use {
354 crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_NAME as NAME,
355 crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION as SPEC_VERSION,
356 };
357 }
358 #[doc = "VK_AMD_display_native_hdr"]
359 pub mod display_native_hdr {
360 use super::super::*;
361 pub use {
362 crate::vk::AMD_DISPLAY_NATIVE_HDR_NAME as NAME,
363 crate::vk::AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION as SPEC_VERSION,
364 };
365 #[doc = "VK_AMD_display_native_hdr device-level functions"]
366 #[derive(Clone)]
367 pub struct Device {
368 pub(crate) fp: DeviceFn,
369 pub(crate) handle: crate::vk::Device,
370 }
371 impl Device {
372 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
373 let handle = device.handle();
374 let fp = DeviceFn::load(|name| unsafe {
375 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
376 });
377 Self { handle, fp }
378 }
379 #[inline]
380 pub fn fp(&self) -> &DeviceFn {
381 &self.fp
382 }
383 #[inline]
384 pub fn device(&self) -> crate::vk::Device {
385 self.handle
386 }
387 }
388 #[derive(Clone)]
389 #[doc = "Raw VK_AMD_display_native_hdr device-level function pointers"]
390 pub struct DeviceFn {
391 pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD,
392 }
393 unsafe impl Send for DeviceFn {}
394 unsafe impl Sync for DeviceFn {}
395 impl DeviceFn {
396 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
397 Self::load_erased(&mut f)
398 }
399 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
400 Self {
401 set_local_dimming_amd: unsafe {
402 unsafe extern "system" fn set_local_dimming_amd(
403 _device: crate::vk::Device,
404 _swap_chain: SwapchainKHR,
405 _local_dimming_enable: Bool32,
406 ) {
407 panic!(concat!(
408 "Unable to load ",
409 stringify!(set_local_dimming_amd)
410 ))
411 }
412 let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0");
413 let val = _f(cname);
414 if val.is_null() {
415 set_local_dimming_amd
416 } else {
417 ::core::mem::transmute(val)
418 }
419 },
420 }
421 }
422 }
423 }
424 #[doc = "VK_AMD_shader_core_properties2"]
425 pub mod shader_core_properties2 {
426 use super::super::*;
427 pub use {
428 crate::vk::AMD_SHADER_CORE_PROPERTIES2_NAME as NAME,
429 crate::vk::AMD_SHADER_CORE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
430 };
431 }
432 #[doc = "VK_AMD_device_coherent_memory"]
433 pub mod device_coherent_memory {
434 use super::super::*;
435 pub use {
436 crate::vk::AMD_DEVICE_COHERENT_MEMORY_NAME as NAME,
437 crate::vk::AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION as SPEC_VERSION,
438 };
439 }
440 #[doc = "VK_AMD_shader_early_and_late_fragment_tests"]
441 pub mod shader_early_and_late_fragment_tests {
442 use super::super::*;
443 pub use {
444 crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_NAME as NAME,
445 crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION as SPEC_VERSION,
446 };
447 }
448}
449#[doc = "Extensions tagged AMDX"]
450pub mod amdx {
451 #[doc = "VK_AMDX_shader_enqueue"]
452 pub mod shader_enqueue {
453 use super::super::*;
454 pub use {
455 crate::vk::AMDX_SHADER_ENQUEUE_NAME as NAME,
456 crate::vk::AMDX_SHADER_ENQUEUE_SPEC_VERSION as SPEC_VERSION,
457 };
458 #[doc = "VK_AMDX_shader_enqueue device-level functions"]
459 #[derive(Clone)]
460 pub struct Device {
461 pub(crate) fp: DeviceFn,
462 pub(crate) handle: crate::vk::Device,
463 }
464 impl Device {
465 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
466 let handle = device.handle();
467 let fp = DeviceFn::load(|name| unsafe {
468 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
469 });
470 Self { handle, fp }
471 }
472 #[inline]
473 pub fn fp(&self) -> &DeviceFn {
474 &self.fp
475 }
476 #[inline]
477 pub fn device(&self) -> crate::vk::Device {
478 self.handle
479 }
480 }
481 #[derive(Clone)]
482 #[doc = "Raw VK_AMDX_shader_enqueue device-level function pointers"]
483 pub struct DeviceFn {
484 pub create_execution_graph_pipelines_amdx: PFN_vkCreateExecutionGraphPipelinesAMDX,
485 pub get_execution_graph_pipeline_scratch_size_amdx:
486 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX,
487 pub get_execution_graph_pipeline_node_index_amdx:
488 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX,
489 pub cmd_initialize_graph_scratch_memory_amdx: PFN_vkCmdInitializeGraphScratchMemoryAMDX,
490 pub cmd_dispatch_graph_amdx: PFN_vkCmdDispatchGraphAMDX,
491 pub cmd_dispatch_graph_indirect_amdx: PFN_vkCmdDispatchGraphIndirectAMDX,
492 pub cmd_dispatch_graph_indirect_count_amdx: PFN_vkCmdDispatchGraphIndirectCountAMDX,
493 }
494 unsafe impl Send for DeviceFn {}
495 unsafe impl Sync for DeviceFn {}
496 impl DeviceFn {
497 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
498 Self::load_erased(&mut f)
499 }
500 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
501 Self {
502 create_execution_graph_pipelines_amdx: unsafe {
503 unsafe extern "system" fn create_execution_graph_pipelines_amdx(
504 _device: crate::vk::Device,
505 _pipeline_cache: PipelineCache,
506 _create_info_count: u32,
507 _p_create_infos: *const ExecutionGraphPipelineCreateInfoAMDX<'_>,
508 _p_allocator: *const AllocationCallbacks<'_>,
509 _p_pipelines: *mut Pipeline,
510 ) -> Result {
511 panic!(concat!(
512 "Unable to load ",
513 stringify!(create_execution_graph_pipelines_amdx)
514 ))
515 }
516 let cname = CStr::from_bytes_with_nul_unchecked(
517 b"vkCreateExecutionGraphPipelinesAMDX\0",
518 );
519 let val = _f(cname);
520 if val.is_null() {
521 create_execution_graph_pipelines_amdx
522 } else {
523 ::core::mem::transmute(val)
524 }
525 },
526 get_execution_graph_pipeline_scratch_size_amdx: unsafe {
527 unsafe extern "system" fn get_execution_graph_pipeline_scratch_size_amdx(
528 _device: crate::vk::Device,
529 _execution_graph: Pipeline,
530 _p_size_info: *mut ExecutionGraphPipelineScratchSizeAMDX<'_>,
531 ) -> Result {
532 panic!(concat!(
533 "Unable to load ",
534 stringify!(get_execution_graph_pipeline_scratch_size_amdx)
535 ))
536 }
537 let cname = CStr::from_bytes_with_nul_unchecked(
538 b"vkGetExecutionGraphPipelineScratchSizeAMDX\0",
539 );
540 let val = _f(cname);
541 if val.is_null() {
542 get_execution_graph_pipeline_scratch_size_amdx
543 } else {
544 ::core::mem::transmute(val)
545 }
546 },
547 get_execution_graph_pipeline_node_index_amdx: unsafe {
548 unsafe extern "system" fn get_execution_graph_pipeline_node_index_amdx(
549 _device: crate::vk::Device,
550 _execution_graph: Pipeline,
551 _p_node_info: *const PipelineShaderStageNodeCreateInfoAMDX<'_>,
552 _p_node_index: *mut u32,
553 ) -> Result {
554 panic!(concat!(
555 "Unable to load ",
556 stringify!(get_execution_graph_pipeline_node_index_amdx)
557 ))
558 }
559 let cname = CStr::from_bytes_with_nul_unchecked(
560 b"vkGetExecutionGraphPipelineNodeIndexAMDX\0",
561 );
562 let val = _f(cname);
563 if val.is_null() {
564 get_execution_graph_pipeline_node_index_amdx
565 } else {
566 ::core::mem::transmute(val)
567 }
568 },
569 cmd_initialize_graph_scratch_memory_amdx: unsafe {
570 unsafe extern "system" fn cmd_initialize_graph_scratch_memory_amdx(
571 _command_buffer: CommandBuffer,
572 _scratch: DeviceAddress,
573 ) {
574 panic!(concat!(
575 "Unable to load ",
576 stringify!(cmd_initialize_graph_scratch_memory_amdx)
577 ))
578 }
579 let cname = CStr::from_bytes_with_nul_unchecked(
580 b"vkCmdInitializeGraphScratchMemoryAMDX\0",
581 );
582 let val = _f(cname);
583 if val.is_null() {
584 cmd_initialize_graph_scratch_memory_amdx
585 } else {
586 ::core::mem::transmute(val)
587 }
588 },
589 cmd_dispatch_graph_amdx: unsafe {
590 unsafe extern "system" fn cmd_dispatch_graph_amdx(
591 _command_buffer: CommandBuffer,
592 _scratch: DeviceAddress,
593 _p_count_info: *const DispatchGraphCountInfoAMDX,
594 ) {
595 panic!(concat!(
596 "Unable to load ",
597 stringify!(cmd_dispatch_graph_amdx)
598 ))
599 }
600 let cname =
601 CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchGraphAMDX\0");
602 let val = _f(cname);
603 if val.is_null() {
604 cmd_dispatch_graph_amdx
605 } else {
606 ::core::mem::transmute(val)
607 }
608 },
609 cmd_dispatch_graph_indirect_amdx: unsafe {
610 unsafe extern "system" fn cmd_dispatch_graph_indirect_amdx(
611 _command_buffer: CommandBuffer,
612 _scratch: DeviceAddress,
613 _p_count_info: *const DispatchGraphCountInfoAMDX,
614 ) {
615 panic!(concat!(
616 "Unable to load ",
617 stringify!(cmd_dispatch_graph_indirect_amdx)
618 ))
619 }
620 let cname = CStr::from_bytes_with_nul_unchecked(
621 b"vkCmdDispatchGraphIndirectAMDX\0",
622 );
623 let val = _f(cname);
624 if val.is_null() {
625 cmd_dispatch_graph_indirect_amdx
626 } else {
627 ::core::mem::transmute(val)
628 }
629 },
630 cmd_dispatch_graph_indirect_count_amdx: unsafe {
631 unsafe extern "system" fn cmd_dispatch_graph_indirect_count_amdx(
632 _command_buffer: CommandBuffer,
633 _scratch: DeviceAddress,
634 _count_info: DeviceAddress,
635 ) {
636 panic!(concat!(
637 "Unable to load ",
638 stringify!(cmd_dispatch_graph_indirect_count_amdx)
639 ))
640 }
641 let cname = CStr::from_bytes_with_nul_unchecked(
642 b"vkCmdDispatchGraphIndirectCountAMDX\0",
643 );
644 let val = _f(cname);
645 if val.is_null() {
646 cmd_dispatch_graph_indirect_count_amdx
647 } else {
648 ::core::mem::transmute(val)
649 }
650 },
651 }
652 }
653 }
654 }
655}
656#[doc = "Extensions tagged ANDROID"]
657pub mod android {
658 #[doc = "VK_ANDROID_native_buffer"]
659 pub mod native_buffer {
660 use super::super::*;
661 pub use {
662 crate::vk::ANDROID_NATIVE_BUFFER_NAME as NAME,
663 crate::vk::ANDROID_NATIVE_BUFFER_SPEC_VERSION as SPEC_VERSION,
664 };
665 #[doc = "VK_ANDROID_native_buffer device-level functions"]
666 #[derive(Clone)]
667 pub struct Device {
668 pub(crate) fp: DeviceFn,
669 pub(crate) handle: crate::vk::Device,
670 }
671 impl Device {
672 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
673 let handle = device.handle();
674 let fp = DeviceFn::load(|name| unsafe {
675 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
676 });
677 Self { handle, fp }
678 }
679 #[inline]
680 pub fn fp(&self) -> &DeviceFn {
681 &self.fp
682 }
683 #[inline]
684 pub fn device(&self) -> crate::vk::Device {
685 self.handle
686 }
687 }
688 #[derive(Clone)]
689 #[doc = "Raw VK_ANDROID_native_buffer device-level function pointers"]
690 pub struct DeviceFn {
691 pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID,
692 pub acquire_image_android: PFN_vkAcquireImageANDROID,
693 pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID,
694 pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID,
695 }
696 unsafe impl Send for DeviceFn {}
697 unsafe impl Sync for DeviceFn {}
698 impl DeviceFn {
699 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
700 Self::load_erased(&mut f)
701 }
702 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
703 Self {
704 get_swapchain_gralloc_usage_android: unsafe {
705 unsafe extern "system" fn get_swapchain_gralloc_usage_android(
706 _device: crate::vk::Device,
707 _format: Format,
708 _image_usage: ImageUsageFlags,
709 _gralloc_usage: *mut c_int,
710 ) -> Result {
711 panic!(concat!(
712 "Unable to load ",
713 stringify!(get_swapchain_gralloc_usage_android)
714 ))
715 }
716 let cname = CStr::from_bytes_with_nul_unchecked(
717 b"vkGetSwapchainGrallocUsageANDROID\0",
718 );
719 let val = _f(cname);
720 if val.is_null() {
721 get_swapchain_gralloc_usage_android
722 } else {
723 ::core::mem::transmute(val)
724 }
725 },
726 acquire_image_android: unsafe {
727 unsafe extern "system" fn acquire_image_android(
728 _device: crate::vk::Device,
729 _image: Image,
730 _native_fence_fd: c_int,
731 _semaphore: Semaphore,
732 _fence: Fence,
733 ) -> Result {
734 panic!(concat!(
735 "Unable to load ",
736 stringify!(acquire_image_android)
737 ))
738 }
739 let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0");
740 let val = _f(cname);
741 if val.is_null() {
742 acquire_image_android
743 } else {
744 ::core::mem::transmute(val)
745 }
746 },
747 queue_signal_release_image_android: unsafe {
748 unsafe extern "system" fn queue_signal_release_image_android(
749 _queue: Queue,
750 _wait_semaphore_count: u32,
751 _p_wait_semaphores: *const Semaphore,
752 _image: Image,
753 _p_native_fence_fd: *mut c_int,
754 ) -> Result {
755 panic!(concat!(
756 "Unable to load ",
757 stringify!(queue_signal_release_image_android)
758 ))
759 }
760 let cname = CStr::from_bytes_with_nul_unchecked(
761 b"vkQueueSignalReleaseImageANDROID\0",
762 );
763 let val = _f(cname);
764 if val.is_null() {
765 queue_signal_release_image_android
766 } else {
767 ::core::mem::transmute(val)
768 }
769 },
770 get_swapchain_gralloc_usage2_android: unsafe {
771 unsafe extern "system" fn get_swapchain_gralloc_usage2_android(
772 _device: crate::vk::Device,
773 _format: Format,
774 _image_usage: ImageUsageFlags,
775 _swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
776 _gralloc_consumer_usage: *mut u64,
777 _gralloc_producer_usage: *mut u64,
778 ) -> Result {
779 panic!(concat!(
780 "Unable to load ",
781 stringify!(get_swapchain_gralloc_usage2_android)
782 ))
783 }
784 let cname = CStr::from_bytes_with_nul_unchecked(
785 b"vkGetSwapchainGrallocUsage2ANDROID\0",
786 );
787 let val = _f(cname);
788 if val.is_null() {
789 get_swapchain_gralloc_usage2_android
790 } else {
791 ::core::mem::transmute(val)
792 }
793 },
794 }
795 }
796 }
797 }
798 #[doc = "VK_ANDROID_external_memory_android_hardware_buffer"]
799 pub mod external_memory_android_hardware_buffer {
800 use super::super::*;
801 pub use {
802 crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_NAME as NAME,
803 crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION as SPEC_VERSION,
804 };
805 #[doc = "VK_ANDROID_external_memory_android_hardware_buffer device-level functions"]
806 #[derive(Clone)]
807 pub struct Device {
808 pub(crate) fp: DeviceFn,
809 pub(crate) handle: crate::vk::Device,
810 }
811 impl Device {
812 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
813 let handle = device.handle();
814 let fp = DeviceFn::load(|name| unsafe {
815 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
816 });
817 Self { handle, fp }
818 }
819 #[inline]
820 pub fn fp(&self) -> &DeviceFn {
821 &self.fp
822 }
823 #[inline]
824 pub fn device(&self) -> crate::vk::Device {
825 self.handle
826 }
827 }
828 #[derive(Clone)]
829 #[doc = "Raw VK_ANDROID_external_memory_android_hardware_buffer device-level function pointers"]
830 pub struct DeviceFn {
831 pub get_android_hardware_buffer_properties_android:
832 PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
833 pub get_memory_android_hardware_buffer_android:
834 PFN_vkGetMemoryAndroidHardwareBufferANDROID,
835 }
836 unsafe impl Send for DeviceFn {}
837 unsafe impl Sync for DeviceFn {}
838 impl DeviceFn {
839 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
840 Self::load_erased(&mut f)
841 }
842 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
843 Self {
844 get_android_hardware_buffer_properties_android: unsafe {
845 unsafe extern "system" fn get_android_hardware_buffer_properties_android(
846 _device: crate::vk::Device,
847 _buffer: *const AHardwareBuffer,
848 _p_properties: *mut AndroidHardwareBufferPropertiesANDROID<'_>,
849 ) -> Result {
850 panic!(concat!(
851 "Unable to load ",
852 stringify!(get_android_hardware_buffer_properties_android)
853 ))
854 }
855 let cname = CStr::from_bytes_with_nul_unchecked(
856 b"vkGetAndroidHardwareBufferPropertiesANDROID\0",
857 );
858 let val = _f(cname);
859 if val.is_null() {
860 get_android_hardware_buffer_properties_android
861 } else {
862 ::core::mem::transmute(val)
863 }
864 },
865 get_memory_android_hardware_buffer_android: unsafe {
866 unsafe extern "system" fn get_memory_android_hardware_buffer_android(
867 _device: crate::vk::Device,
868 _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
869 _p_buffer: *mut *mut AHardwareBuffer,
870 ) -> Result {
871 panic!(concat!(
872 "Unable to load ",
873 stringify!(get_memory_android_hardware_buffer_android)
874 ))
875 }
876 let cname = CStr::from_bytes_with_nul_unchecked(
877 b"vkGetMemoryAndroidHardwareBufferANDROID\0",
878 );
879 let val = _f(cname);
880 if val.is_null() {
881 get_memory_android_hardware_buffer_android
882 } else {
883 ::core::mem::transmute(val)
884 }
885 },
886 }
887 }
888 }
889 }
890 #[doc = "VK_ANDROID_external_format_resolve"]
891 pub mod external_format_resolve {
892 use super::super::*;
893 pub use {
894 crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_NAME as NAME,
895 crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION as SPEC_VERSION,
896 };
897 }
898}
899#[doc = "Extensions tagged ARM"]
900pub mod arm {
901 #[doc = "VK_ARM_rasterization_order_attachment_access"]
902 pub mod rasterization_order_attachment_access {
903 use super::super::*;
904 pub use {
905 crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME,
906 crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION,
907 };
908 }
909 #[doc = "VK_ARM_shader_core_properties"]
910 pub mod shader_core_properties {
911 use super::super::*;
912 pub use {
913 crate::vk::ARM_SHADER_CORE_PROPERTIES_NAME as NAME,
914 crate::vk::ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
915 };
916 }
917 #[doc = "VK_ARM_scheduling_controls"]
918 pub mod scheduling_controls {
919 use super::super::*;
920 pub use {
921 crate::vk::ARM_SCHEDULING_CONTROLS_NAME as NAME,
922 crate::vk::ARM_SCHEDULING_CONTROLS_SPEC_VERSION as SPEC_VERSION,
923 };
924 }
925 #[doc = "VK_ARM_render_pass_striped"]
926 pub mod render_pass_striped {
927 use super::super::*;
928 pub use {
929 crate::vk::ARM_RENDER_PASS_STRIPED_NAME as NAME,
930 crate::vk::ARM_RENDER_PASS_STRIPED_SPEC_VERSION as SPEC_VERSION,
931 };
932 }
933 #[doc = "VK_ARM_shader_core_builtins"]
934 pub mod shader_core_builtins {
935 use super::super::*;
936 pub use {
937 crate::vk::ARM_SHADER_CORE_BUILTINS_NAME as NAME,
938 crate::vk::ARM_SHADER_CORE_BUILTINS_SPEC_VERSION as SPEC_VERSION,
939 };
940 }
941}
942#[doc = "Extensions tagged EXT"]
943pub mod ext {
944 #[doc = "VK_EXT_debug_report"]
945 pub mod debug_report {
946 use super::super::*;
947 pub use {
948 crate::vk::EXT_DEBUG_REPORT_NAME as NAME,
949 crate::vk::EXT_DEBUG_REPORT_SPEC_VERSION as SPEC_VERSION,
950 };
951 #[doc = "VK_EXT_debug_report instance-level functions"]
952 #[derive(Clone)]
953 pub struct Instance {
954 pub(crate) fp: InstanceFn,
955 pub(crate) handle: crate::vk::Instance,
956 }
957 impl Instance {
958 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
959 let handle = instance.handle();
960 let fp = InstanceFn::load(|name| unsafe {
961 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
962 });
963 Self { handle, fp }
964 }
965 #[inline]
966 pub fn fp(&self) -> &InstanceFn {
967 &self.fp
968 }
969 #[inline]
970 pub fn instance(&self) -> crate::vk::Instance {
971 self.handle
972 }
973 }
974 #[derive(Clone)]
975 #[doc = "Raw VK_EXT_debug_report instance-level function pointers"]
976 pub struct InstanceFn {
977 pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT,
978 pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT,
979 pub debug_report_message_ext: PFN_vkDebugReportMessageEXT,
980 }
981 unsafe impl Send for InstanceFn {}
982 unsafe impl Sync for InstanceFn {}
983 impl InstanceFn {
984 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
985 Self::load_erased(&mut f)
986 }
987 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
988 Self {
989 create_debug_report_callback_ext: unsafe {
990 unsafe extern "system" fn create_debug_report_callback_ext(
991 _instance: crate::vk::Instance,
992 _p_create_info: *const DebugReportCallbackCreateInfoEXT<'_>,
993 _p_allocator: *const AllocationCallbacks<'_>,
994 _p_callback: *mut DebugReportCallbackEXT,
995 ) -> Result {
996 panic!(concat!(
997 "Unable to load ",
998 stringify!(create_debug_report_callback_ext)
999 ))
1000 }
1001 let cname = CStr::from_bytes_with_nul_unchecked(
1002 b"vkCreateDebugReportCallbackEXT\0",
1003 );
1004 let val = _f(cname);
1005 if val.is_null() {
1006 create_debug_report_callback_ext
1007 } else {
1008 ::core::mem::transmute(val)
1009 }
1010 },
1011 destroy_debug_report_callback_ext: unsafe {
1012 unsafe extern "system" fn destroy_debug_report_callback_ext(
1013 _instance: crate::vk::Instance,
1014 _callback: DebugReportCallbackEXT,
1015 _p_allocator: *const AllocationCallbacks<'_>,
1016 ) {
1017 panic!(concat!(
1018 "Unable to load ",
1019 stringify!(destroy_debug_report_callback_ext)
1020 ))
1021 }
1022 let cname = CStr::from_bytes_with_nul_unchecked(
1023 b"vkDestroyDebugReportCallbackEXT\0",
1024 );
1025 let val = _f(cname);
1026 if val.is_null() {
1027 destroy_debug_report_callback_ext
1028 } else {
1029 ::core::mem::transmute(val)
1030 }
1031 },
1032 debug_report_message_ext: unsafe {
1033 unsafe extern "system" fn debug_report_message_ext(
1034 _instance: crate::vk::Instance,
1035 _flags: DebugReportFlagsEXT,
1036 _object_type: DebugReportObjectTypeEXT,
1037 _object: u64,
1038 _location: usize,
1039 _message_code: i32,
1040 _p_layer_prefix: *const c_char,
1041 _p_message: *const c_char,
1042 ) {
1043 panic!(concat!(
1044 "Unable to load ",
1045 stringify!(debug_report_message_ext)
1046 ))
1047 }
1048 let cname =
1049 CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0");
1050 let val = _f(cname);
1051 if val.is_null() {
1052 debug_report_message_ext
1053 } else {
1054 ::core::mem::transmute(val)
1055 }
1056 },
1057 }
1058 }
1059 }
1060 }
1061 #[doc = "VK_EXT_depth_range_unrestricted"]
1062 pub mod depth_range_unrestricted {
1063 use super::super::*;
1064 pub use {
1065 crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_NAME as NAME,
1066 crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION as SPEC_VERSION,
1067 };
1068 }
1069 #[doc = "VK_EXT_debug_marker"]
1070 pub mod debug_marker {
1071 use super::super::*;
1072 pub use {
1073 crate::vk::EXT_DEBUG_MARKER_NAME as NAME,
1074 crate::vk::EXT_DEBUG_MARKER_SPEC_VERSION as SPEC_VERSION,
1075 };
1076 #[doc = "VK_EXT_debug_marker device-level functions"]
1077 #[derive(Clone)]
1078 pub struct Device {
1079 pub(crate) fp: DeviceFn,
1080 pub(crate) handle: crate::vk::Device,
1081 }
1082 impl Device {
1083 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
1084 let handle = device.handle();
1085 let fp = DeviceFn::load(|name| unsafe {
1086 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
1087 });
1088 Self { handle, fp }
1089 }
1090 #[inline]
1091 pub fn fp(&self) -> &DeviceFn {
1092 &self.fp
1093 }
1094 #[inline]
1095 pub fn device(&self) -> crate::vk::Device {
1096 self.handle
1097 }
1098 }
1099 #[derive(Clone)]
1100 #[doc = "Raw VK_EXT_debug_marker device-level function pointers"]
1101 pub struct DeviceFn {
1102 pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT,
1103 pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT,
1104 pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT,
1105 pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT,
1106 pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT,
1107 }
1108 unsafe impl Send for DeviceFn {}
1109 unsafe impl Sync for DeviceFn {}
1110 impl DeviceFn {
1111 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1112 Self::load_erased(&mut f)
1113 }
1114 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1115 Self {
1116 debug_marker_set_object_tag_ext: unsafe {
1117 unsafe extern "system" fn debug_marker_set_object_tag_ext(
1118 _device: crate::vk::Device,
1119 _p_tag_info: *const DebugMarkerObjectTagInfoEXT<'_>,
1120 ) -> Result {
1121 panic!(concat!(
1122 "Unable to load ",
1123 stringify!(debug_marker_set_object_tag_ext)
1124 ))
1125 }
1126 let cname =
1127 CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectTagEXT\0");
1128 let val = _f(cname);
1129 if val.is_null() {
1130 debug_marker_set_object_tag_ext
1131 } else {
1132 ::core::mem::transmute(val)
1133 }
1134 },
1135 debug_marker_set_object_name_ext: unsafe {
1136 unsafe extern "system" fn debug_marker_set_object_name_ext(
1137 _device: crate::vk::Device,
1138 _p_name_info: *const DebugMarkerObjectNameInfoEXT<'_>,
1139 ) -> Result {
1140 panic!(concat!(
1141 "Unable to load ",
1142 stringify!(debug_marker_set_object_name_ext)
1143 ))
1144 }
1145 let cname =
1146 CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectNameEXT\0");
1147 let val = _f(cname);
1148 if val.is_null() {
1149 debug_marker_set_object_name_ext
1150 } else {
1151 ::core::mem::transmute(val)
1152 }
1153 },
1154 cmd_debug_marker_begin_ext: unsafe {
1155 unsafe extern "system" fn cmd_debug_marker_begin_ext(
1156 _command_buffer: CommandBuffer,
1157 _p_marker_info: *const DebugMarkerMarkerInfoEXT<'_>,
1158 ) {
1159 panic!(concat!(
1160 "Unable to load ",
1161 stringify!(cmd_debug_marker_begin_ext)
1162 ))
1163 }
1164 let cname =
1165 CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0");
1166 let val = _f(cname);
1167 if val.is_null() {
1168 cmd_debug_marker_begin_ext
1169 } else {
1170 ::core::mem::transmute(val)
1171 }
1172 },
1173 cmd_debug_marker_end_ext: unsafe {
1174 unsafe extern "system" fn cmd_debug_marker_end_ext(
1175 _command_buffer: CommandBuffer,
1176 ) {
1177 panic!(concat!(
1178 "Unable to load ",
1179 stringify!(cmd_debug_marker_end_ext)
1180 ))
1181 }
1182 let cname =
1183 CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0");
1184 let val = _f(cname);
1185 if val.is_null() {
1186 cmd_debug_marker_end_ext
1187 } else {
1188 ::core::mem::transmute(val)
1189 }
1190 },
1191 cmd_debug_marker_insert_ext: unsafe {
1192 unsafe extern "system" fn cmd_debug_marker_insert_ext(
1193 _command_buffer: CommandBuffer,
1194 _p_marker_info: *const DebugMarkerMarkerInfoEXT<'_>,
1195 ) {
1196 panic!(concat!(
1197 "Unable to load ",
1198 stringify!(cmd_debug_marker_insert_ext)
1199 ))
1200 }
1201 let cname =
1202 CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0");
1203 let val = _f(cname);
1204 if val.is_null() {
1205 cmd_debug_marker_insert_ext
1206 } else {
1207 ::core::mem::transmute(val)
1208 }
1209 },
1210 }
1211 }
1212 }
1213 }
1214 #[doc = "VK_EXT_transform_feedback"]
1215 pub mod transform_feedback {
1216 use super::super::*;
1217 pub use {
1218 crate::vk::EXT_TRANSFORM_FEEDBACK_NAME as NAME,
1219 crate::vk::EXT_TRANSFORM_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
1220 };
1221 #[doc = "VK_EXT_transform_feedback device-level functions"]
1222 #[derive(Clone)]
1223 pub struct Device {
1224 pub(crate) fp: DeviceFn,
1225 pub(crate) handle: crate::vk::Device,
1226 }
1227 impl Device {
1228 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
1229 let handle = device.handle();
1230 let fp = DeviceFn::load(|name| unsafe {
1231 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
1232 });
1233 Self { handle, fp }
1234 }
1235 #[inline]
1236 pub fn fp(&self) -> &DeviceFn {
1237 &self.fp
1238 }
1239 #[inline]
1240 pub fn device(&self) -> crate::vk::Device {
1241 self.handle
1242 }
1243 }
1244 #[derive(Clone)]
1245 #[doc = "Raw VK_EXT_transform_feedback device-level function pointers"]
1246 pub struct DeviceFn {
1247 pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT,
1248 pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT,
1249 pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT,
1250 pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT,
1251 pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT,
1252 pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT,
1253 }
1254 unsafe impl Send for DeviceFn {}
1255 unsafe impl Sync for DeviceFn {}
1256 impl DeviceFn {
1257 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1258 Self::load_erased(&mut f)
1259 }
1260 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1261 Self {
1262 cmd_bind_transform_feedback_buffers_ext: unsafe {
1263 unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext(
1264 _command_buffer: CommandBuffer,
1265 _first_binding: u32,
1266 _binding_count: u32,
1267 _p_buffers: *const Buffer,
1268 _p_offsets: *const DeviceSize,
1269 _p_sizes: *const DeviceSize,
1270 ) {
1271 panic!(concat!(
1272 "Unable to load ",
1273 stringify!(cmd_bind_transform_feedback_buffers_ext)
1274 ))
1275 }
1276 let cname = CStr::from_bytes_with_nul_unchecked(
1277 b"vkCmdBindTransformFeedbackBuffersEXT\0",
1278 );
1279 let val = _f(cname);
1280 if val.is_null() {
1281 cmd_bind_transform_feedback_buffers_ext
1282 } else {
1283 ::core::mem::transmute(val)
1284 }
1285 },
1286 cmd_begin_transform_feedback_ext: unsafe {
1287 unsafe extern "system" fn cmd_begin_transform_feedback_ext(
1288 _command_buffer: CommandBuffer,
1289 _first_counter_buffer: u32,
1290 _counter_buffer_count: u32,
1291 _p_counter_buffers: *const Buffer,
1292 _p_counter_buffer_offsets: *const DeviceSize,
1293 ) {
1294 panic!(concat!(
1295 "Unable to load ",
1296 stringify!(cmd_begin_transform_feedback_ext)
1297 ))
1298 }
1299 let cname = CStr::from_bytes_with_nul_unchecked(
1300 b"vkCmdBeginTransformFeedbackEXT\0",
1301 );
1302 let val = _f(cname);
1303 if val.is_null() {
1304 cmd_begin_transform_feedback_ext
1305 } else {
1306 ::core::mem::transmute(val)
1307 }
1308 },
1309 cmd_end_transform_feedback_ext: unsafe {
1310 unsafe extern "system" fn cmd_end_transform_feedback_ext(
1311 _command_buffer: CommandBuffer,
1312 _first_counter_buffer: u32,
1313 _counter_buffer_count: u32,
1314 _p_counter_buffers: *const Buffer,
1315 _p_counter_buffer_offsets: *const DeviceSize,
1316 ) {
1317 panic!(concat!(
1318 "Unable to load ",
1319 stringify!(cmd_end_transform_feedback_ext)
1320 ))
1321 }
1322 let cname =
1323 CStr::from_bytes_with_nul_unchecked(b"vkCmdEndTransformFeedbackEXT\0");
1324 let val = _f(cname);
1325 if val.is_null() {
1326 cmd_end_transform_feedback_ext
1327 } else {
1328 ::core::mem::transmute(val)
1329 }
1330 },
1331 cmd_begin_query_indexed_ext: unsafe {
1332 unsafe extern "system" fn cmd_begin_query_indexed_ext(
1333 _command_buffer: CommandBuffer,
1334 _query_pool: QueryPool,
1335 _query: u32,
1336 _flags: QueryControlFlags,
1337 _index: u32,
1338 ) {
1339 panic!(concat!(
1340 "Unable to load ",
1341 stringify!(cmd_begin_query_indexed_ext)
1342 ))
1343 }
1344 let cname =
1345 CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0");
1346 let val = _f(cname);
1347 if val.is_null() {
1348 cmd_begin_query_indexed_ext
1349 } else {
1350 ::core::mem::transmute(val)
1351 }
1352 },
1353 cmd_end_query_indexed_ext: unsafe {
1354 unsafe extern "system" fn cmd_end_query_indexed_ext(
1355 _command_buffer: CommandBuffer,
1356 _query_pool: QueryPool,
1357 _query: u32,
1358 _index: u32,
1359 ) {
1360 panic!(concat!(
1361 "Unable to load ",
1362 stringify!(cmd_end_query_indexed_ext)
1363 ))
1364 }
1365 let cname =
1366 CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0");
1367 let val = _f(cname);
1368 if val.is_null() {
1369 cmd_end_query_indexed_ext
1370 } else {
1371 ::core::mem::transmute(val)
1372 }
1373 },
1374 cmd_draw_indirect_byte_count_ext: unsafe {
1375 unsafe extern "system" fn cmd_draw_indirect_byte_count_ext(
1376 _command_buffer: CommandBuffer,
1377 _instance_count: u32,
1378 _first_instance: u32,
1379 _counter_buffer: Buffer,
1380 _counter_buffer_offset: DeviceSize,
1381 _counter_offset: u32,
1382 _vertex_stride: u32,
1383 ) {
1384 panic!(concat!(
1385 "Unable to load ",
1386 stringify!(cmd_draw_indirect_byte_count_ext)
1387 ))
1388 }
1389 let cname =
1390 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectByteCountEXT\0");
1391 let val = _f(cname);
1392 if val.is_null() {
1393 cmd_draw_indirect_byte_count_ext
1394 } else {
1395 ::core::mem::transmute(val)
1396 }
1397 },
1398 }
1399 }
1400 }
1401 }
1402 #[doc = "VK_EXT_validation_flags"]
1403 pub mod validation_flags {
1404 use super::super::*;
1405 pub use {
1406 crate::vk::EXT_VALIDATION_FLAGS_NAME as NAME,
1407 crate::vk::EXT_VALIDATION_FLAGS_SPEC_VERSION as SPEC_VERSION,
1408 };
1409 }
1410 #[doc = "VK_EXT_shader_subgroup_ballot"]
1411 pub mod shader_subgroup_ballot {
1412 use super::super::*;
1413 pub use {
1414 crate::vk::EXT_SHADER_SUBGROUP_BALLOT_NAME as NAME,
1415 crate::vk::EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION as SPEC_VERSION,
1416 };
1417 }
1418 #[doc = "VK_EXT_shader_subgroup_vote"]
1419 pub mod shader_subgroup_vote {
1420 use super::super::*;
1421 pub use {
1422 crate::vk::EXT_SHADER_SUBGROUP_VOTE_NAME as NAME,
1423 crate::vk::EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION as SPEC_VERSION,
1424 };
1425 }
1426 #[doc = "VK_EXT_texture_compression_astc_hdr"]
1427 pub mod texture_compression_astc_hdr {
1428 use super::super::*;
1429 pub use {
1430 crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_NAME as NAME,
1431 crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION as SPEC_VERSION,
1432 };
1433 }
1434 #[doc = "VK_EXT_astc_decode_mode"]
1435 pub mod astc_decode_mode {
1436 use super::super::*;
1437 pub use {
1438 crate::vk::EXT_ASTC_DECODE_MODE_NAME as NAME,
1439 crate::vk::EXT_ASTC_DECODE_MODE_SPEC_VERSION as SPEC_VERSION,
1440 };
1441 }
1442 #[doc = "VK_EXT_pipeline_robustness"]
1443 pub mod pipeline_robustness {
1444 use super::super::*;
1445 pub use {
1446 crate::vk::EXT_PIPELINE_ROBUSTNESS_NAME as NAME,
1447 crate::vk::EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION,
1448 };
1449 }
1450 #[doc = "VK_EXT_conditional_rendering"]
1451 pub mod conditional_rendering {
1452 use super::super::*;
1453 pub use {
1454 crate::vk::EXT_CONDITIONAL_RENDERING_NAME as NAME,
1455 crate::vk::EXT_CONDITIONAL_RENDERING_SPEC_VERSION as SPEC_VERSION,
1456 };
1457 #[doc = "VK_EXT_conditional_rendering device-level functions"]
1458 #[derive(Clone)]
1459 pub struct Device {
1460 pub(crate) fp: DeviceFn,
1461 pub(crate) handle: crate::vk::Device,
1462 }
1463 impl Device {
1464 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
1465 let handle = device.handle();
1466 let fp = DeviceFn::load(|name| unsafe {
1467 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
1468 });
1469 Self { handle, fp }
1470 }
1471 #[inline]
1472 pub fn fp(&self) -> &DeviceFn {
1473 &self.fp
1474 }
1475 #[inline]
1476 pub fn device(&self) -> crate::vk::Device {
1477 self.handle
1478 }
1479 }
1480 #[derive(Clone)]
1481 #[doc = "Raw VK_EXT_conditional_rendering device-level function pointers"]
1482 pub struct DeviceFn {
1483 pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT,
1484 pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT,
1485 }
1486 unsafe impl Send for DeviceFn {}
1487 unsafe impl Sync for DeviceFn {}
1488 impl DeviceFn {
1489 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1490 Self::load_erased(&mut f)
1491 }
1492 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1493 Self {
1494 cmd_begin_conditional_rendering_ext: unsafe {
1495 unsafe extern "system" fn cmd_begin_conditional_rendering_ext(
1496 _command_buffer: CommandBuffer,
1497 _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT<
1498 '_,
1499 >,
1500 ) {
1501 panic!(concat!(
1502 "Unable to load ",
1503 stringify!(cmd_begin_conditional_rendering_ext)
1504 ))
1505 }
1506 let cname = CStr::from_bytes_with_nul_unchecked(
1507 b"vkCmdBeginConditionalRenderingEXT\0",
1508 );
1509 let val = _f(cname);
1510 if val.is_null() {
1511 cmd_begin_conditional_rendering_ext
1512 } else {
1513 ::core::mem::transmute(val)
1514 }
1515 },
1516 cmd_end_conditional_rendering_ext: unsafe {
1517 unsafe extern "system" fn cmd_end_conditional_rendering_ext(
1518 _command_buffer: CommandBuffer,
1519 ) {
1520 panic!(concat!(
1521 "Unable to load ",
1522 stringify!(cmd_end_conditional_rendering_ext)
1523 ))
1524 }
1525 let cname = CStr::from_bytes_with_nul_unchecked(
1526 b"vkCmdEndConditionalRenderingEXT\0",
1527 );
1528 let val = _f(cname);
1529 if val.is_null() {
1530 cmd_end_conditional_rendering_ext
1531 } else {
1532 ::core::mem::transmute(val)
1533 }
1534 },
1535 }
1536 }
1537 }
1538 }
1539 #[doc = "VK_EXT_direct_mode_display"]
1540 pub mod direct_mode_display {
1541 use super::super::*;
1542 pub use {
1543 crate::vk::EXT_DIRECT_MODE_DISPLAY_NAME as NAME,
1544 crate::vk::EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION as SPEC_VERSION,
1545 };
1546 #[doc = "VK_EXT_direct_mode_display instance-level functions"]
1547 #[derive(Clone)]
1548 pub struct Instance {
1549 pub(crate) fp: InstanceFn,
1550 pub(crate) handle: crate::vk::Instance,
1551 }
1552 impl Instance {
1553 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
1554 let handle = instance.handle();
1555 let fp = InstanceFn::load(|name| unsafe {
1556 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
1557 });
1558 Self { handle, fp }
1559 }
1560 #[inline]
1561 pub fn fp(&self) -> &InstanceFn {
1562 &self.fp
1563 }
1564 #[inline]
1565 pub fn instance(&self) -> crate::vk::Instance {
1566 self.handle
1567 }
1568 }
1569 #[derive(Clone)]
1570 #[doc = "Raw VK_EXT_direct_mode_display instance-level function pointers"]
1571 pub struct InstanceFn {
1572 pub release_display_ext: PFN_vkReleaseDisplayEXT,
1573 }
1574 unsafe impl Send for InstanceFn {}
1575 unsafe impl Sync for InstanceFn {}
1576 impl InstanceFn {
1577 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1578 Self::load_erased(&mut f)
1579 }
1580 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1581 Self {
1582 release_display_ext: unsafe {
1583 unsafe extern "system" fn release_display_ext(
1584 _physical_device: PhysicalDevice,
1585 _display: DisplayKHR,
1586 ) -> Result {
1587 panic!(concat!("Unable to load ", stringify!(release_display_ext)))
1588 }
1589 let cname = CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0");
1590 let val = _f(cname);
1591 if val.is_null() {
1592 release_display_ext
1593 } else {
1594 ::core::mem::transmute(val)
1595 }
1596 },
1597 }
1598 }
1599 }
1600 }
1601 #[doc = "VK_EXT_acquire_xlib_display"]
1602 pub mod acquire_xlib_display {
1603 use super::super::*;
1604 pub use {
1605 crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_NAME as NAME,
1606 crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION as SPEC_VERSION,
1607 };
1608 #[doc = "VK_EXT_acquire_xlib_display instance-level functions"]
1609 #[derive(Clone)]
1610 pub struct Instance {
1611 pub(crate) fp: InstanceFn,
1612 pub(crate) handle: crate::vk::Instance,
1613 }
1614 impl Instance {
1615 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
1616 let handle = instance.handle();
1617 let fp = InstanceFn::load(|name| unsafe {
1618 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
1619 });
1620 Self { handle, fp }
1621 }
1622 #[inline]
1623 pub fn fp(&self) -> &InstanceFn {
1624 &self.fp
1625 }
1626 #[inline]
1627 pub fn instance(&self) -> crate::vk::Instance {
1628 self.handle
1629 }
1630 }
1631 #[derive(Clone)]
1632 #[doc = "Raw VK_EXT_acquire_xlib_display instance-level function pointers"]
1633 pub struct InstanceFn {
1634 pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT,
1635 pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT,
1636 }
1637 unsafe impl Send for InstanceFn {}
1638 unsafe impl Sync for InstanceFn {}
1639 impl InstanceFn {
1640 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1641 Self::load_erased(&mut f)
1642 }
1643 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1644 Self {
1645 acquire_xlib_display_ext: unsafe {
1646 unsafe extern "system" fn acquire_xlib_display_ext(
1647 _physical_device: PhysicalDevice,
1648 _dpy: *mut Display,
1649 _display: DisplayKHR,
1650 ) -> Result {
1651 panic!(concat!(
1652 "Unable to load ",
1653 stringify!(acquire_xlib_display_ext)
1654 ))
1655 }
1656 let cname =
1657 CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0");
1658 let val = _f(cname);
1659 if val.is_null() {
1660 acquire_xlib_display_ext
1661 } else {
1662 ::core::mem::transmute(val)
1663 }
1664 },
1665 get_rand_r_output_display_ext: unsafe {
1666 unsafe extern "system" fn get_rand_r_output_display_ext(
1667 _physical_device: PhysicalDevice,
1668 _dpy: *mut Display,
1669 _rr_output: RROutput,
1670 _p_display: *mut DisplayKHR,
1671 ) -> Result {
1672 panic!(concat!(
1673 "Unable to load ",
1674 stringify!(get_rand_r_output_display_ext)
1675 ))
1676 }
1677 let cname =
1678 CStr::from_bytes_with_nul_unchecked(b"vkGetRandROutputDisplayEXT\0");
1679 let val = _f(cname);
1680 if val.is_null() {
1681 get_rand_r_output_display_ext
1682 } else {
1683 ::core::mem::transmute(val)
1684 }
1685 },
1686 }
1687 }
1688 }
1689 }
1690 #[doc = "VK_EXT_display_surface_counter"]
1691 pub mod display_surface_counter {
1692 use super::super::*;
1693 pub use {
1694 crate::vk::EXT_DISPLAY_SURFACE_COUNTER_NAME as NAME,
1695 crate::vk::EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION as SPEC_VERSION,
1696 };
1697 #[doc = "VK_EXT_display_surface_counter instance-level functions"]
1698 #[derive(Clone)]
1699 pub struct Instance {
1700 pub(crate) fp: InstanceFn,
1701 pub(crate) handle: crate::vk::Instance,
1702 }
1703 impl Instance {
1704 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
1705 let handle = instance.handle();
1706 let fp = InstanceFn::load(|name| unsafe {
1707 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
1708 });
1709 Self { handle, fp }
1710 }
1711 #[inline]
1712 pub fn fp(&self) -> &InstanceFn {
1713 &self.fp
1714 }
1715 #[inline]
1716 pub fn instance(&self) -> crate::vk::Instance {
1717 self.handle
1718 }
1719 }
1720 #[derive(Clone)]
1721 #[doc = "Raw VK_EXT_display_surface_counter instance-level function pointers"]
1722 pub struct InstanceFn {
1723 pub get_physical_device_surface_capabilities2_ext:
1724 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
1725 }
1726 unsafe impl Send for InstanceFn {}
1727 unsafe impl Sync for InstanceFn {}
1728 impl InstanceFn {
1729 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1730 Self::load_erased(&mut f)
1731 }
1732 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1733 Self {
1734 get_physical_device_surface_capabilities2_ext: unsafe {
1735 unsafe extern "system" fn get_physical_device_surface_capabilities2_ext(
1736 _physical_device: PhysicalDevice,
1737 _surface: SurfaceKHR,
1738 _p_surface_capabilities: *mut SurfaceCapabilities2EXT<'_>,
1739 ) -> Result {
1740 panic!(concat!(
1741 "Unable to load ",
1742 stringify!(get_physical_device_surface_capabilities2_ext)
1743 ))
1744 }
1745 let cname = CStr::from_bytes_with_nul_unchecked(
1746 b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0",
1747 );
1748 let val = _f(cname);
1749 if val.is_null() {
1750 get_physical_device_surface_capabilities2_ext
1751 } else {
1752 ::core::mem::transmute(val)
1753 }
1754 },
1755 }
1756 }
1757 }
1758 }
1759 #[doc = "VK_EXT_display_control"]
1760 pub mod display_control {
1761 use super::super::*;
1762 pub use {
1763 crate::vk::EXT_DISPLAY_CONTROL_NAME as NAME,
1764 crate::vk::EXT_DISPLAY_CONTROL_SPEC_VERSION as SPEC_VERSION,
1765 };
1766 #[doc = "VK_EXT_display_control device-level functions"]
1767 #[derive(Clone)]
1768 pub struct Device {
1769 pub(crate) fp: DeviceFn,
1770 pub(crate) handle: crate::vk::Device,
1771 }
1772 impl Device {
1773 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
1774 let handle = device.handle();
1775 let fp = DeviceFn::load(|name| unsafe {
1776 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
1777 });
1778 Self { handle, fp }
1779 }
1780 #[inline]
1781 pub fn fp(&self) -> &DeviceFn {
1782 &self.fp
1783 }
1784 #[inline]
1785 pub fn device(&self) -> crate::vk::Device {
1786 self.handle
1787 }
1788 }
1789 #[derive(Clone)]
1790 #[doc = "Raw VK_EXT_display_control device-level function pointers"]
1791 pub struct DeviceFn {
1792 pub display_power_control_ext: PFN_vkDisplayPowerControlEXT,
1793 pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT,
1794 pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT,
1795 pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT,
1796 }
1797 unsafe impl Send for DeviceFn {}
1798 unsafe impl Sync for DeviceFn {}
1799 impl DeviceFn {
1800 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1801 Self::load_erased(&mut f)
1802 }
1803 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1804 Self {
1805 display_power_control_ext: unsafe {
1806 unsafe extern "system" fn display_power_control_ext(
1807 _device: crate::vk::Device,
1808 _display: DisplayKHR,
1809 _p_display_power_info: *const DisplayPowerInfoEXT<'_>,
1810 ) -> Result {
1811 panic!(concat!(
1812 "Unable to load ",
1813 stringify!(display_power_control_ext)
1814 ))
1815 }
1816 let cname =
1817 CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0");
1818 let val = _f(cname);
1819 if val.is_null() {
1820 display_power_control_ext
1821 } else {
1822 ::core::mem::transmute(val)
1823 }
1824 },
1825 register_device_event_ext: unsafe {
1826 unsafe extern "system" fn register_device_event_ext(
1827 _device: crate::vk::Device,
1828 _p_device_event_info: *const DeviceEventInfoEXT<'_>,
1829 _p_allocator: *const AllocationCallbacks<'_>,
1830 _p_fence: *mut Fence,
1831 ) -> Result {
1832 panic!(concat!(
1833 "Unable to load ",
1834 stringify!(register_device_event_ext)
1835 ))
1836 }
1837 let cname =
1838 CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0");
1839 let val = _f(cname);
1840 if val.is_null() {
1841 register_device_event_ext
1842 } else {
1843 ::core::mem::transmute(val)
1844 }
1845 },
1846 register_display_event_ext: unsafe {
1847 unsafe extern "system" fn register_display_event_ext(
1848 _device: crate::vk::Device,
1849 _display: DisplayKHR,
1850 _p_display_event_info: *const DisplayEventInfoEXT<'_>,
1851 _p_allocator: *const AllocationCallbacks<'_>,
1852 _p_fence: *mut Fence,
1853 ) -> Result {
1854 panic!(concat!(
1855 "Unable to load ",
1856 stringify!(register_display_event_ext)
1857 ))
1858 }
1859 let cname =
1860 CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0");
1861 let val = _f(cname);
1862 if val.is_null() {
1863 register_display_event_ext
1864 } else {
1865 ::core::mem::transmute(val)
1866 }
1867 },
1868 get_swapchain_counter_ext: unsafe {
1869 unsafe extern "system" fn get_swapchain_counter_ext(
1870 _device: crate::vk::Device,
1871 _swapchain: SwapchainKHR,
1872 _counter: SurfaceCounterFlagsEXT,
1873 _p_counter_value: *mut u64,
1874 ) -> Result {
1875 panic!(concat!(
1876 "Unable to load ",
1877 stringify!(get_swapchain_counter_ext)
1878 ))
1879 }
1880 let cname =
1881 CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0");
1882 let val = _f(cname);
1883 if val.is_null() {
1884 get_swapchain_counter_ext
1885 } else {
1886 ::core::mem::transmute(val)
1887 }
1888 },
1889 }
1890 }
1891 }
1892 }
1893 #[doc = "VK_EXT_discard_rectangles"]
1894 pub mod discard_rectangles {
1895 use super::super::*;
1896 pub use {
1897 crate::vk::EXT_DISCARD_RECTANGLES_NAME as NAME,
1898 crate::vk::EXT_DISCARD_RECTANGLES_SPEC_VERSION as SPEC_VERSION,
1899 };
1900 #[doc = "VK_EXT_discard_rectangles device-level functions"]
1901 #[derive(Clone)]
1902 pub struct Device {
1903 pub(crate) fp: DeviceFn,
1904 pub(crate) handle: crate::vk::Device,
1905 }
1906 impl Device {
1907 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
1908 let handle = device.handle();
1909 let fp = DeviceFn::load(|name| unsafe {
1910 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
1911 });
1912 Self { handle, fp }
1913 }
1914 #[inline]
1915 pub fn fp(&self) -> &DeviceFn {
1916 &self.fp
1917 }
1918 #[inline]
1919 pub fn device(&self) -> crate::vk::Device {
1920 self.handle
1921 }
1922 }
1923 #[derive(Clone)]
1924 #[doc = "Raw VK_EXT_discard_rectangles device-level function pointers"]
1925 pub struct DeviceFn {
1926 pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT,
1927 pub cmd_set_discard_rectangle_enable_ext: PFN_vkCmdSetDiscardRectangleEnableEXT,
1928 pub cmd_set_discard_rectangle_mode_ext: PFN_vkCmdSetDiscardRectangleModeEXT,
1929 }
1930 unsafe impl Send for DeviceFn {}
1931 unsafe impl Sync for DeviceFn {}
1932 impl DeviceFn {
1933 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
1934 Self::load_erased(&mut f)
1935 }
1936 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
1937 Self {
1938 cmd_set_discard_rectangle_ext: unsafe {
1939 unsafe extern "system" fn cmd_set_discard_rectangle_ext(
1940 _command_buffer: CommandBuffer,
1941 _first_discard_rectangle: u32,
1942 _discard_rectangle_count: u32,
1943 _p_discard_rectangles: *const Rect2D,
1944 ) {
1945 panic!(concat!(
1946 "Unable to load ",
1947 stringify!(cmd_set_discard_rectangle_ext)
1948 ))
1949 }
1950 let cname =
1951 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDiscardRectangleEXT\0");
1952 let val = _f(cname);
1953 if val.is_null() {
1954 cmd_set_discard_rectangle_ext
1955 } else {
1956 ::core::mem::transmute(val)
1957 }
1958 },
1959 cmd_set_discard_rectangle_enable_ext: unsafe {
1960 unsafe extern "system" fn cmd_set_discard_rectangle_enable_ext(
1961 _command_buffer: CommandBuffer,
1962 _discard_rectangle_enable: Bool32,
1963 ) {
1964 panic!(concat!(
1965 "Unable to load ",
1966 stringify!(cmd_set_discard_rectangle_enable_ext)
1967 ))
1968 }
1969 let cname = CStr::from_bytes_with_nul_unchecked(
1970 b"vkCmdSetDiscardRectangleEnableEXT\0",
1971 );
1972 let val = _f(cname);
1973 if val.is_null() {
1974 cmd_set_discard_rectangle_enable_ext
1975 } else {
1976 ::core::mem::transmute(val)
1977 }
1978 },
1979 cmd_set_discard_rectangle_mode_ext: unsafe {
1980 unsafe extern "system" fn cmd_set_discard_rectangle_mode_ext(
1981 _command_buffer: CommandBuffer,
1982 _discard_rectangle_mode: DiscardRectangleModeEXT,
1983 ) {
1984 panic!(concat!(
1985 "Unable to load ",
1986 stringify!(cmd_set_discard_rectangle_mode_ext)
1987 ))
1988 }
1989 let cname = CStr::from_bytes_with_nul_unchecked(
1990 b"vkCmdSetDiscardRectangleModeEXT\0",
1991 );
1992 let val = _f(cname);
1993 if val.is_null() {
1994 cmd_set_discard_rectangle_mode_ext
1995 } else {
1996 ::core::mem::transmute(val)
1997 }
1998 },
1999 }
2000 }
2001 }
2002 }
2003 #[doc = "VK_EXT_conservative_rasterization"]
2004 pub mod conservative_rasterization {
2005 use super::super::*;
2006 pub use {
2007 crate::vk::EXT_CONSERVATIVE_RASTERIZATION_NAME as NAME,
2008 crate::vk::EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
2009 };
2010 }
2011 #[doc = "VK_EXT_depth_clip_enable"]
2012 pub mod depth_clip_enable {
2013 use super::super::*;
2014 pub use {
2015 crate::vk::EXT_DEPTH_CLIP_ENABLE_NAME as NAME,
2016 crate::vk::EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION as SPEC_VERSION,
2017 };
2018 }
2019 #[doc = "VK_EXT_swapchain_colorspace"]
2020 pub mod swapchain_colorspace {
2021 use super::super::*;
2022 pub use {
2023 crate::vk::EXT_SWAPCHAIN_COLORSPACE_NAME as NAME,
2024 crate::vk::EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION as SPEC_VERSION,
2025 };
2026 }
2027 #[doc = "VK_EXT_hdr_metadata"]
2028 pub mod hdr_metadata {
2029 use super::super::*;
2030 pub use {
2031 crate::vk::EXT_HDR_METADATA_NAME as NAME,
2032 crate::vk::EXT_HDR_METADATA_SPEC_VERSION as SPEC_VERSION,
2033 };
2034 #[doc = "VK_EXT_hdr_metadata device-level functions"]
2035 #[derive(Clone)]
2036 pub struct Device {
2037 pub(crate) fp: DeviceFn,
2038 pub(crate) handle: crate::vk::Device,
2039 }
2040 impl Device {
2041 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2042 let handle = device.handle();
2043 let fp = DeviceFn::load(|name| unsafe {
2044 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2045 });
2046 Self { handle, fp }
2047 }
2048 #[inline]
2049 pub fn fp(&self) -> &DeviceFn {
2050 &self.fp
2051 }
2052 #[inline]
2053 pub fn device(&self) -> crate::vk::Device {
2054 self.handle
2055 }
2056 }
2057 #[derive(Clone)]
2058 #[doc = "Raw VK_EXT_hdr_metadata device-level function pointers"]
2059 pub struct DeviceFn {
2060 pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT,
2061 }
2062 unsafe impl Send for DeviceFn {}
2063 unsafe impl Sync for DeviceFn {}
2064 impl DeviceFn {
2065 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2066 Self::load_erased(&mut f)
2067 }
2068 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2069 Self {
2070 set_hdr_metadata_ext: unsafe {
2071 unsafe extern "system" fn set_hdr_metadata_ext(
2072 _device: crate::vk::Device,
2073 _swapchain_count: u32,
2074 _p_swapchains: *const SwapchainKHR,
2075 _p_metadata: *const HdrMetadataEXT<'_>,
2076 ) {
2077 panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext)))
2078 }
2079 let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0");
2080 let val = _f(cname);
2081 if val.is_null() {
2082 set_hdr_metadata_ext
2083 } else {
2084 ::core::mem::transmute(val)
2085 }
2086 },
2087 }
2088 }
2089 }
2090 }
2091 #[doc = "VK_EXT_external_memory_dma_buf"]
2092 pub mod external_memory_dma_buf {
2093 use super::super::*;
2094 pub use {
2095 crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_NAME as NAME,
2096 crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION as SPEC_VERSION,
2097 };
2098 }
2099 #[doc = "VK_EXT_queue_family_foreign"]
2100 pub mod queue_family_foreign {
2101 use super::super::*;
2102 pub use {
2103 crate::vk::EXT_QUEUE_FAMILY_FOREIGN_NAME as NAME,
2104 crate::vk::EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION as SPEC_VERSION,
2105 };
2106 }
2107 #[doc = "VK_EXT_debug_utils"]
2108 pub mod debug_utils {
2109 use super::super::*;
2110 pub use {
2111 crate::vk::EXT_DEBUG_UTILS_NAME as NAME,
2112 crate::vk::EXT_DEBUG_UTILS_SPEC_VERSION as SPEC_VERSION,
2113 };
2114 #[doc = "VK_EXT_debug_utils instance-level functions"]
2115 #[derive(Clone)]
2116 pub struct Instance {
2117 pub(crate) fp: InstanceFn,
2118 pub(crate) handle: crate::vk::Instance,
2119 }
2120 impl Instance {
2121 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
2122 let handle = instance.handle();
2123 let fp = InstanceFn::load(|name| unsafe {
2124 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
2125 });
2126 Self { handle, fp }
2127 }
2128 #[inline]
2129 pub fn fp(&self) -> &InstanceFn {
2130 &self.fp
2131 }
2132 #[inline]
2133 pub fn instance(&self) -> crate::vk::Instance {
2134 self.handle
2135 }
2136 }
2137 #[derive(Clone)]
2138 #[doc = "Raw VK_EXT_debug_utils instance-level function pointers"]
2139 pub struct InstanceFn {
2140 pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT,
2141 pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT,
2142 pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT,
2143 }
2144 unsafe impl Send for InstanceFn {}
2145 unsafe impl Sync for InstanceFn {}
2146 impl InstanceFn {
2147 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2148 Self::load_erased(&mut f)
2149 }
2150 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2151 Self {
2152 create_debug_utils_messenger_ext: unsafe {
2153 unsafe extern "system" fn create_debug_utils_messenger_ext(
2154 _instance: crate::vk::Instance,
2155 _p_create_info: *const DebugUtilsMessengerCreateInfoEXT<'_>,
2156 _p_allocator: *const AllocationCallbacks<'_>,
2157 _p_messenger: *mut DebugUtilsMessengerEXT,
2158 ) -> Result {
2159 panic!(concat!(
2160 "Unable to load ",
2161 stringify!(create_debug_utils_messenger_ext)
2162 ))
2163 }
2164 let cname = CStr::from_bytes_with_nul_unchecked(
2165 b"vkCreateDebugUtilsMessengerEXT\0",
2166 );
2167 let val = _f(cname);
2168 if val.is_null() {
2169 create_debug_utils_messenger_ext
2170 } else {
2171 ::core::mem::transmute(val)
2172 }
2173 },
2174 destroy_debug_utils_messenger_ext: unsafe {
2175 unsafe extern "system" fn destroy_debug_utils_messenger_ext(
2176 _instance: crate::vk::Instance,
2177 _messenger: DebugUtilsMessengerEXT,
2178 _p_allocator: *const AllocationCallbacks<'_>,
2179 ) {
2180 panic!(concat!(
2181 "Unable to load ",
2182 stringify!(destroy_debug_utils_messenger_ext)
2183 ))
2184 }
2185 let cname = CStr::from_bytes_with_nul_unchecked(
2186 b"vkDestroyDebugUtilsMessengerEXT\0",
2187 );
2188 let val = _f(cname);
2189 if val.is_null() {
2190 destroy_debug_utils_messenger_ext
2191 } else {
2192 ::core::mem::transmute(val)
2193 }
2194 },
2195 submit_debug_utils_message_ext: unsafe {
2196 unsafe extern "system" fn submit_debug_utils_message_ext(
2197 _instance: crate::vk::Instance,
2198 _message_severity: DebugUtilsMessageSeverityFlagsEXT,
2199 _message_types: DebugUtilsMessageTypeFlagsEXT,
2200 _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT<'_>,
2201 ) {
2202 panic!(concat!(
2203 "Unable to load ",
2204 stringify!(submit_debug_utils_message_ext)
2205 ))
2206 }
2207 let cname =
2208 CStr::from_bytes_with_nul_unchecked(b"vkSubmitDebugUtilsMessageEXT\0");
2209 let val = _f(cname);
2210 if val.is_null() {
2211 submit_debug_utils_message_ext
2212 } else {
2213 ::core::mem::transmute(val)
2214 }
2215 },
2216 }
2217 }
2218 }
2219 #[doc = "VK_EXT_debug_utils device-level functions"]
2220 #[derive(Clone)]
2221 pub struct Device {
2222 pub(crate) fp: DeviceFn,
2223 pub(crate) handle: crate::vk::Device,
2224 }
2225 impl Device {
2226 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2227 let handle = device.handle();
2228 let fp = DeviceFn::load(|name| unsafe {
2229 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2230 });
2231 Self { handle, fp }
2232 }
2233 #[inline]
2234 pub fn fp(&self) -> &DeviceFn {
2235 &self.fp
2236 }
2237 #[inline]
2238 pub fn device(&self) -> crate::vk::Device {
2239 self.handle
2240 }
2241 }
2242 #[derive(Clone)]
2243 #[doc = "Raw VK_EXT_debug_utils device-level function pointers"]
2244 pub struct DeviceFn {
2245 pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT,
2246 pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT,
2247 pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT,
2248 pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT,
2249 pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT,
2250 pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT,
2251 pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT,
2252 pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT,
2253 }
2254 unsafe impl Send for DeviceFn {}
2255 unsafe impl Sync for DeviceFn {}
2256 impl DeviceFn {
2257 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2258 Self::load_erased(&mut f)
2259 }
2260 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2261 Self {
2262 set_debug_utils_object_name_ext: unsafe {
2263 unsafe extern "system" fn set_debug_utils_object_name_ext(
2264 _device: crate::vk::Device,
2265 _p_name_info: *const DebugUtilsObjectNameInfoEXT<'_>,
2266 ) -> Result {
2267 panic!(concat!(
2268 "Unable to load ",
2269 stringify!(set_debug_utils_object_name_ext)
2270 ))
2271 }
2272 let cname =
2273 CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectNameEXT\0");
2274 let val = _f(cname);
2275 if val.is_null() {
2276 set_debug_utils_object_name_ext
2277 } else {
2278 ::core::mem::transmute(val)
2279 }
2280 },
2281 set_debug_utils_object_tag_ext: unsafe {
2282 unsafe extern "system" fn set_debug_utils_object_tag_ext(
2283 _device: crate::vk::Device,
2284 _p_tag_info: *const DebugUtilsObjectTagInfoEXT<'_>,
2285 ) -> Result {
2286 panic!(concat!(
2287 "Unable to load ",
2288 stringify!(set_debug_utils_object_tag_ext)
2289 ))
2290 }
2291 let cname =
2292 CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectTagEXT\0");
2293 let val = _f(cname);
2294 if val.is_null() {
2295 set_debug_utils_object_tag_ext
2296 } else {
2297 ::core::mem::transmute(val)
2298 }
2299 },
2300 queue_begin_debug_utils_label_ext: unsafe {
2301 unsafe extern "system" fn queue_begin_debug_utils_label_ext(
2302 _queue: Queue,
2303 _p_label_info: *const DebugUtilsLabelEXT<'_>,
2304 ) {
2305 panic!(concat!(
2306 "Unable to load ",
2307 stringify!(queue_begin_debug_utils_label_ext)
2308 ))
2309 }
2310 let cname = CStr::from_bytes_with_nul_unchecked(
2311 b"vkQueueBeginDebugUtilsLabelEXT\0",
2312 );
2313 let val = _f(cname);
2314 if val.is_null() {
2315 queue_begin_debug_utils_label_ext
2316 } else {
2317 ::core::mem::transmute(val)
2318 }
2319 },
2320 queue_end_debug_utils_label_ext: unsafe {
2321 unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) {
2322 panic!(concat!(
2323 "Unable to load ",
2324 stringify!(queue_end_debug_utils_label_ext)
2325 ))
2326 }
2327 let cname =
2328 CStr::from_bytes_with_nul_unchecked(b"vkQueueEndDebugUtilsLabelEXT\0");
2329 let val = _f(cname);
2330 if val.is_null() {
2331 queue_end_debug_utils_label_ext
2332 } else {
2333 ::core::mem::transmute(val)
2334 }
2335 },
2336 queue_insert_debug_utils_label_ext: unsafe {
2337 unsafe extern "system" fn queue_insert_debug_utils_label_ext(
2338 _queue: Queue,
2339 _p_label_info: *const DebugUtilsLabelEXT<'_>,
2340 ) {
2341 panic!(concat!(
2342 "Unable to load ",
2343 stringify!(queue_insert_debug_utils_label_ext)
2344 ))
2345 }
2346 let cname = CStr::from_bytes_with_nul_unchecked(
2347 b"vkQueueInsertDebugUtilsLabelEXT\0",
2348 );
2349 let val = _f(cname);
2350 if val.is_null() {
2351 queue_insert_debug_utils_label_ext
2352 } else {
2353 ::core::mem::transmute(val)
2354 }
2355 },
2356 cmd_begin_debug_utils_label_ext: unsafe {
2357 unsafe extern "system" fn cmd_begin_debug_utils_label_ext(
2358 _command_buffer: CommandBuffer,
2359 _p_label_info: *const DebugUtilsLabelEXT<'_>,
2360 ) {
2361 panic!(concat!(
2362 "Unable to load ",
2363 stringify!(cmd_begin_debug_utils_label_ext)
2364 ))
2365 }
2366 let cname =
2367 CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginDebugUtilsLabelEXT\0");
2368 let val = _f(cname);
2369 if val.is_null() {
2370 cmd_begin_debug_utils_label_ext
2371 } else {
2372 ::core::mem::transmute(val)
2373 }
2374 },
2375 cmd_end_debug_utils_label_ext: unsafe {
2376 unsafe extern "system" fn cmd_end_debug_utils_label_ext(
2377 _command_buffer: CommandBuffer,
2378 ) {
2379 panic!(concat!(
2380 "Unable to load ",
2381 stringify!(cmd_end_debug_utils_label_ext)
2382 ))
2383 }
2384 let cname =
2385 CStr::from_bytes_with_nul_unchecked(b"vkCmdEndDebugUtilsLabelEXT\0");
2386 let val = _f(cname);
2387 if val.is_null() {
2388 cmd_end_debug_utils_label_ext
2389 } else {
2390 ::core::mem::transmute(val)
2391 }
2392 },
2393 cmd_insert_debug_utils_label_ext: unsafe {
2394 unsafe extern "system" fn cmd_insert_debug_utils_label_ext(
2395 _command_buffer: CommandBuffer,
2396 _p_label_info: *const DebugUtilsLabelEXT<'_>,
2397 ) {
2398 panic!(concat!(
2399 "Unable to load ",
2400 stringify!(cmd_insert_debug_utils_label_ext)
2401 ))
2402 }
2403 let cname =
2404 CStr::from_bytes_with_nul_unchecked(b"vkCmdInsertDebugUtilsLabelEXT\0");
2405 let val = _f(cname);
2406 if val.is_null() {
2407 cmd_insert_debug_utils_label_ext
2408 } else {
2409 ::core::mem::transmute(val)
2410 }
2411 },
2412 }
2413 }
2414 }
2415 }
2416 #[doc = "VK_EXT_sampler_filter_minmax"]
2417 pub mod sampler_filter_minmax {
2418 use super::super::*;
2419 pub use {
2420 crate::vk::EXT_SAMPLER_FILTER_MINMAX_NAME as NAME,
2421 crate::vk::EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION as SPEC_VERSION,
2422 };
2423 }
2424 #[doc = "VK_EXT_inline_uniform_block"]
2425 pub mod inline_uniform_block {
2426 use super::super::*;
2427 pub use {
2428 crate::vk::EXT_INLINE_UNIFORM_BLOCK_NAME as NAME,
2429 crate::vk::EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION as SPEC_VERSION,
2430 };
2431 }
2432 #[doc = "VK_EXT_shader_stencil_export"]
2433 pub mod shader_stencil_export {
2434 use super::super::*;
2435 pub use {
2436 crate::vk::EXT_SHADER_STENCIL_EXPORT_NAME as NAME,
2437 crate::vk::EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION as SPEC_VERSION,
2438 };
2439 }
2440 #[doc = "VK_EXT_sample_locations"]
2441 pub mod sample_locations {
2442 use super::super::*;
2443 pub use {
2444 crate::vk::EXT_SAMPLE_LOCATIONS_NAME as NAME,
2445 crate::vk::EXT_SAMPLE_LOCATIONS_SPEC_VERSION as SPEC_VERSION,
2446 };
2447 #[doc = "VK_EXT_sample_locations instance-level functions"]
2448 #[derive(Clone)]
2449 pub struct Instance {
2450 pub(crate) fp: InstanceFn,
2451 pub(crate) handle: crate::vk::Instance,
2452 }
2453 impl Instance {
2454 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
2455 let handle = instance.handle();
2456 let fp = InstanceFn::load(|name| unsafe {
2457 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
2458 });
2459 Self { handle, fp }
2460 }
2461 #[inline]
2462 pub fn fp(&self) -> &InstanceFn {
2463 &self.fp
2464 }
2465 #[inline]
2466 pub fn instance(&self) -> crate::vk::Instance {
2467 self.handle
2468 }
2469 }
2470 #[derive(Clone)]
2471 #[doc = "Raw VK_EXT_sample_locations instance-level function pointers"]
2472 pub struct InstanceFn {
2473 pub get_physical_device_multisample_properties_ext:
2474 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
2475 }
2476 unsafe impl Send for InstanceFn {}
2477 unsafe impl Sync for InstanceFn {}
2478 impl InstanceFn {
2479 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2480 Self::load_erased(&mut f)
2481 }
2482 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2483 Self {
2484 get_physical_device_multisample_properties_ext: unsafe {
2485 unsafe extern "system" fn get_physical_device_multisample_properties_ext(
2486 _physical_device: PhysicalDevice,
2487 _samples: SampleCountFlags,
2488 _p_multisample_properties: *mut MultisamplePropertiesEXT<'_>,
2489 ) {
2490 panic!(concat!(
2491 "Unable to load ",
2492 stringify!(get_physical_device_multisample_properties_ext)
2493 ))
2494 }
2495 let cname = CStr::from_bytes_with_nul_unchecked(
2496 b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0",
2497 );
2498 let val = _f(cname);
2499 if val.is_null() {
2500 get_physical_device_multisample_properties_ext
2501 } else {
2502 ::core::mem::transmute(val)
2503 }
2504 },
2505 }
2506 }
2507 }
2508 #[doc = "VK_EXT_sample_locations device-level functions"]
2509 #[derive(Clone)]
2510 pub struct Device {
2511 pub(crate) fp: DeviceFn,
2512 pub(crate) handle: crate::vk::Device,
2513 }
2514 impl Device {
2515 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2516 let handle = device.handle();
2517 let fp = DeviceFn::load(|name| unsafe {
2518 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2519 });
2520 Self { handle, fp }
2521 }
2522 #[inline]
2523 pub fn fp(&self) -> &DeviceFn {
2524 &self.fp
2525 }
2526 #[inline]
2527 pub fn device(&self) -> crate::vk::Device {
2528 self.handle
2529 }
2530 }
2531 #[derive(Clone)]
2532 #[doc = "Raw VK_EXT_sample_locations device-level function pointers"]
2533 pub struct DeviceFn {
2534 pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT,
2535 }
2536 unsafe impl Send for DeviceFn {}
2537 unsafe impl Sync for DeviceFn {}
2538 impl DeviceFn {
2539 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2540 Self::load_erased(&mut f)
2541 }
2542 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2543 Self {
2544 cmd_set_sample_locations_ext: unsafe {
2545 unsafe extern "system" fn cmd_set_sample_locations_ext(
2546 _command_buffer: CommandBuffer,
2547 _p_sample_locations_info: *const SampleLocationsInfoEXT<'_>,
2548 ) {
2549 panic!(concat!(
2550 "Unable to load ",
2551 stringify!(cmd_set_sample_locations_ext)
2552 ))
2553 }
2554 let cname =
2555 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleLocationsEXT\0");
2556 let val = _f(cname);
2557 if val.is_null() {
2558 cmd_set_sample_locations_ext
2559 } else {
2560 ::core::mem::transmute(val)
2561 }
2562 },
2563 }
2564 }
2565 }
2566 }
2567 #[doc = "VK_EXT_blend_operation_advanced"]
2568 pub mod blend_operation_advanced {
2569 use super::super::*;
2570 pub use {
2571 crate::vk::EXT_BLEND_OPERATION_ADVANCED_NAME as NAME,
2572 crate::vk::EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION as SPEC_VERSION,
2573 };
2574 }
2575 #[doc = "VK_EXT_post_depth_coverage"]
2576 pub mod post_depth_coverage {
2577 use super::super::*;
2578 pub use {
2579 crate::vk::EXT_POST_DEPTH_COVERAGE_NAME as NAME,
2580 crate::vk::EXT_POST_DEPTH_COVERAGE_SPEC_VERSION as SPEC_VERSION,
2581 };
2582 }
2583 #[doc = "VK_EXT_image_drm_format_modifier"]
2584 pub mod image_drm_format_modifier {
2585 use super::super::*;
2586 pub use {
2587 crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_NAME as NAME,
2588 crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION as SPEC_VERSION,
2589 };
2590 #[doc = "VK_EXT_image_drm_format_modifier device-level functions"]
2591 #[derive(Clone)]
2592 pub struct Device {
2593 pub(crate) fp: DeviceFn,
2594 pub(crate) handle: crate::vk::Device,
2595 }
2596 impl Device {
2597 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2598 let handle = device.handle();
2599 let fp = DeviceFn::load(|name| unsafe {
2600 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2601 });
2602 Self { handle, fp }
2603 }
2604 #[inline]
2605 pub fn fp(&self) -> &DeviceFn {
2606 &self.fp
2607 }
2608 #[inline]
2609 pub fn device(&self) -> crate::vk::Device {
2610 self.handle
2611 }
2612 }
2613 #[derive(Clone)]
2614 #[doc = "Raw VK_EXT_image_drm_format_modifier device-level function pointers"]
2615 pub struct DeviceFn {
2616 pub get_image_drm_format_modifier_properties_ext:
2617 PFN_vkGetImageDrmFormatModifierPropertiesEXT,
2618 }
2619 unsafe impl Send for DeviceFn {}
2620 unsafe impl Sync for DeviceFn {}
2621 impl DeviceFn {
2622 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2623 Self::load_erased(&mut f)
2624 }
2625 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2626 Self {
2627 get_image_drm_format_modifier_properties_ext: unsafe {
2628 unsafe extern "system" fn get_image_drm_format_modifier_properties_ext(
2629 _device: crate::vk::Device,
2630 _image: Image,
2631 _p_properties: *mut ImageDrmFormatModifierPropertiesEXT<'_>,
2632 ) -> Result {
2633 panic!(concat!(
2634 "Unable to load ",
2635 stringify!(get_image_drm_format_modifier_properties_ext)
2636 ))
2637 }
2638 let cname = CStr::from_bytes_with_nul_unchecked(
2639 b"vkGetImageDrmFormatModifierPropertiesEXT\0",
2640 );
2641 let val = _f(cname);
2642 if val.is_null() {
2643 get_image_drm_format_modifier_properties_ext
2644 } else {
2645 ::core::mem::transmute(val)
2646 }
2647 },
2648 }
2649 }
2650 }
2651 }
2652 #[doc = "VK_EXT_validation_cache"]
2653 pub mod validation_cache {
2654 use super::super::*;
2655 pub use {
2656 crate::vk::EXT_VALIDATION_CACHE_NAME as NAME,
2657 crate::vk::EXT_VALIDATION_CACHE_SPEC_VERSION as SPEC_VERSION,
2658 };
2659 #[doc = "VK_EXT_validation_cache device-level functions"]
2660 #[derive(Clone)]
2661 pub struct Device {
2662 pub(crate) fp: DeviceFn,
2663 pub(crate) handle: crate::vk::Device,
2664 }
2665 impl Device {
2666 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2667 let handle = device.handle();
2668 let fp = DeviceFn::load(|name| unsafe {
2669 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2670 });
2671 Self { handle, fp }
2672 }
2673 #[inline]
2674 pub fn fp(&self) -> &DeviceFn {
2675 &self.fp
2676 }
2677 #[inline]
2678 pub fn device(&self) -> crate::vk::Device {
2679 self.handle
2680 }
2681 }
2682 #[derive(Clone)]
2683 #[doc = "Raw VK_EXT_validation_cache device-level function pointers"]
2684 pub struct DeviceFn {
2685 pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT,
2686 pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT,
2687 pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT,
2688 pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT,
2689 }
2690 unsafe impl Send for DeviceFn {}
2691 unsafe impl Sync for DeviceFn {}
2692 impl DeviceFn {
2693 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2694 Self::load_erased(&mut f)
2695 }
2696 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2697 Self {
2698 create_validation_cache_ext: unsafe {
2699 unsafe extern "system" fn create_validation_cache_ext(
2700 _device: crate::vk::Device,
2701 _p_create_info: *const ValidationCacheCreateInfoEXT<'_>,
2702 _p_allocator: *const AllocationCallbacks<'_>,
2703 _p_validation_cache: *mut ValidationCacheEXT,
2704 ) -> Result {
2705 panic!(concat!(
2706 "Unable to load ",
2707 stringify!(create_validation_cache_ext)
2708 ))
2709 }
2710 let cname =
2711 CStr::from_bytes_with_nul_unchecked(b"vkCreateValidationCacheEXT\0");
2712 let val = _f(cname);
2713 if val.is_null() {
2714 create_validation_cache_ext
2715 } else {
2716 ::core::mem::transmute(val)
2717 }
2718 },
2719 destroy_validation_cache_ext: unsafe {
2720 unsafe extern "system" fn destroy_validation_cache_ext(
2721 _device: crate::vk::Device,
2722 _validation_cache: ValidationCacheEXT,
2723 _p_allocator: *const AllocationCallbacks<'_>,
2724 ) {
2725 panic!(concat!(
2726 "Unable to load ",
2727 stringify!(destroy_validation_cache_ext)
2728 ))
2729 }
2730 let cname =
2731 CStr::from_bytes_with_nul_unchecked(b"vkDestroyValidationCacheEXT\0");
2732 let val = _f(cname);
2733 if val.is_null() {
2734 destroy_validation_cache_ext
2735 } else {
2736 ::core::mem::transmute(val)
2737 }
2738 },
2739 merge_validation_caches_ext: unsafe {
2740 unsafe extern "system" fn merge_validation_caches_ext(
2741 _device: crate::vk::Device,
2742 _dst_cache: ValidationCacheEXT,
2743 _src_cache_count: u32,
2744 _p_src_caches: *const ValidationCacheEXT,
2745 ) -> Result {
2746 panic!(concat!(
2747 "Unable to load ",
2748 stringify!(merge_validation_caches_ext)
2749 ))
2750 }
2751 let cname =
2752 CStr::from_bytes_with_nul_unchecked(b"vkMergeValidationCachesEXT\0");
2753 let val = _f(cname);
2754 if val.is_null() {
2755 merge_validation_caches_ext
2756 } else {
2757 ::core::mem::transmute(val)
2758 }
2759 },
2760 get_validation_cache_data_ext: unsafe {
2761 unsafe extern "system" fn get_validation_cache_data_ext(
2762 _device: crate::vk::Device,
2763 _validation_cache: ValidationCacheEXT,
2764 _p_data_size: *mut usize,
2765 _p_data: *mut c_void,
2766 ) -> Result {
2767 panic!(concat!(
2768 "Unable to load ",
2769 stringify!(get_validation_cache_data_ext)
2770 ))
2771 }
2772 let cname =
2773 CStr::from_bytes_with_nul_unchecked(b"vkGetValidationCacheDataEXT\0");
2774 let val = _f(cname);
2775 if val.is_null() {
2776 get_validation_cache_data_ext
2777 } else {
2778 ::core::mem::transmute(val)
2779 }
2780 },
2781 }
2782 }
2783 }
2784 }
2785 #[doc = "VK_EXT_descriptor_indexing"]
2786 pub mod descriptor_indexing {
2787 use super::super::*;
2788 pub use {
2789 crate::vk::EXT_DESCRIPTOR_INDEXING_NAME as NAME,
2790 crate::vk::EXT_DESCRIPTOR_INDEXING_SPEC_VERSION as SPEC_VERSION,
2791 };
2792 }
2793 #[doc = "VK_EXT_shader_viewport_index_layer"]
2794 pub mod shader_viewport_index_layer {
2795 use super::super::*;
2796 pub use {
2797 crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_NAME as NAME,
2798 crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION as SPEC_VERSION,
2799 };
2800 }
2801 #[doc = "VK_EXT_filter_cubic"]
2802 pub mod filter_cubic {
2803 use super::super::*;
2804 pub use {
2805 crate::vk::EXT_FILTER_CUBIC_NAME as NAME,
2806 crate::vk::EXT_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION,
2807 };
2808 }
2809 #[doc = "VK_EXT_global_priority"]
2810 pub mod global_priority {
2811 use super::super::*;
2812 pub use {
2813 crate::vk::EXT_GLOBAL_PRIORITY_NAME as NAME,
2814 crate::vk::EXT_GLOBAL_PRIORITY_SPEC_VERSION as SPEC_VERSION,
2815 };
2816 }
2817 #[doc = "VK_EXT_external_memory_host"]
2818 pub mod external_memory_host {
2819 use super::super::*;
2820 pub use {
2821 crate::vk::EXT_EXTERNAL_MEMORY_HOST_NAME as NAME,
2822 crate::vk::EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION as SPEC_VERSION,
2823 };
2824 #[doc = "VK_EXT_external_memory_host device-level functions"]
2825 #[derive(Clone)]
2826 pub struct Device {
2827 pub(crate) fp: DeviceFn,
2828 pub(crate) handle: crate::vk::Device,
2829 }
2830 impl Device {
2831 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2832 let handle = device.handle();
2833 let fp = DeviceFn::load(|name| unsafe {
2834 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2835 });
2836 Self { handle, fp }
2837 }
2838 #[inline]
2839 pub fn fp(&self) -> &DeviceFn {
2840 &self.fp
2841 }
2842 #[inline]
2843 pub fn device(&self) -> crate::vk::Device {
2844 self.handle
2845 }
2846 }
2847 #[derive(Clone)]
2848 #[doc = "Raw VK_EXT_external_memory_host device-level function pointers"]
2849 pub struct DeviceFn {
2850 pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT,
2851 }
2852 unsafe impl Send for DeviceFn {}
2853 unsafe impl Sync for DeviceFn {}
2854 impl DeviceFn {
2855 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2856 Self::load_erased(&mut f)
2857 }
2858 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2859 Self {
2860 get_memory_host_pointer_properties_ext: unsafe {
2861 unsafe extern "system" fn get_memory_host_pointer_properties_ext(
2862 _device: crate::vk::Device,
2863 _handle_type: ExternalMemoryHandleTypeFlags,
2864 _p_host_pointer: *const c_void,
2865 _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT<
2866 '_,
2867 >,
2868 ) -> Result {
2869 panic!(concat!(
2870 "Unable to load ",
2871 stringify!(get_memory_host_pointer_properties_ext)
2872 ))
2873 }
2874 let cname = CStr::from_bytes_with_nul_unchecked(
2875 b"vkGetMemoryHostPointerPropertiesEXT\0",
2876 );
2877 let val = _f(cname);
2878 if val.is_null() {
2879 get_memory_host_pointer_properties_ext
2880 } else {
2881 ::core::mem::transmute(val)
2882 }
2883 },
2884 }
2885 }
2886 }
2887 }
2888 #[doc = "VK_EXT_calibrated_timestamps"]
2889 pub mod calibrated_timestamps {
2890 use super::super::*;
2891 pub use {
2892 crate::vk::EXT_CALIBRATED_TIMESTAMPS_NAME as NAME,
2893 crate::vk::EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION as SPEC_VERSION,
2894 };
2895 #[doc = "VK_EXT_calibrated_timestamps instance-level functions"]
2896 #[derive(Clone)]
2897 pub struct Instance {
2898 pub(crate) fp: InstanceFn,
2899 pub(crate) handle: crate::vk::Instance,
2900 }
2901 impl Instance {
2902 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
2903 let handle = instance.handle();
2904 let fp = InstanceFn::load(|name| unsafe {
2905 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
2906 });
2907 Self { handle, fp }
2908 }
2909 #[inline]
2910 pub fn fp(&self) -> &InstanceFn {
2911 &self.fp
2912 }
2913 #[inline]
2914 pub fn instance(&self) -> crate::vk::Instance {
2915 self.handle
2916 }
2917 }
2918 #[derive(Clone)]
2919 #[doc = "Raw VK_EXT_calibrated_timestamps instance-level function pointers"]
2920 pub struct InstanceFn {
2921 pub get_physical_device_calibrateable_time_domains_ext:
2922 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR,
2923 }
2924 unsafe impl Send for InstanceFn {}
2925 unsafe impl Sync for InstanceFn {}
2926 impl InstanceFn {
2927 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2928 Self::load_erased(&mut f)
2929 }
2930 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2931 Self {
2932 get_physical_device_calibrateable_time_domains_ext: unsafe {
2933 unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext(
2934 _physical_device: PhysicalDevice,
2935 _p_time_domain_count: *mut u32,
2936 _p_time_domains: *mut TimeDomainKHR,
2937 ) -> Result {
2938 panic!(concat!(
2939 "Unable to load ",
2940 stringify!(get_physical_device_calibrateable_time_domains_ext)
2941 ))
2942 }
2943 let cname = CStr::from_bytes_with_nul_unchecked(
2944 b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0",
2945 );
2946 let val = _f(cname);
2947 if val.is_null() {
2948 get_physical_device_calibrateable_time_domains_ext
2949 } else {
2950 ::core::mem::transmute(val)
2951 }
2952 },
2953 }
2954 }
2955 }
2956 #[doc = "VK_EXT_calibrated_timestamps device-level functions"]
2957 #[derive(Clone)]
2958 pub struct Device {
2959 pub(crate) fp: DeviceFn,
2960 pub(crate) handle: crate::vk::Device,
2961 }
2962 impl Device {
2963 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
2964 let handle = device.handle();
2965 let fp = DeviceFn::load(|name| unsafe {
2966 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
2967 });
2968 Self { handle, fp }
2969 }
2970 #[inline]
2971 pub fn fp(&self) -> &DeviceFn {
2972 &self.fp
2973 }
2974 #[inline]
2975 pub fn device(&self) -> crate::vk::Device {
2976 self.handle
2977 }
2978 }
2979 #[derive(Clone)]
2980 #[doc = "Raw VK_EXT_calibrated_timestamps device-level function pointers"]
2981 pub struct DeviceFn {
2982 pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsKHR,
2983 }
2984 unsafe impl Send for DeviceFn {}
2985 unsafe impl Sync for DeviceFn {}
2986 impl DeviceFn {
2987 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
2988 Self::load_erased(&mut f)
2989 }
2990 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
2991 Self {
2992 get_calibrated_timestamps_ext: unsafe {
2993 unsafe extern "system" fn get_calibrated_timestamps_ext(
2994 _device: crate::vk::Device,
2995 _timestamp_count: u32,
2996 _p_timestamp_infos: *const CalibratedTimestampInfoKHR<'_>,
2997 _p_timestamps: *mut u64,
2998 _p_max_deviation: *mut u64,
2999 ) -> Result {
3000 panic!(concat!(
3001 "Unable to load ",
3002 stringify!(get_calibrated_timestamps_ext)
3003 ))
3004 }
3005 let cname =
3006 CStr::from_bytes_with_nul_unchecked(b"vkGetCalibratedTimestampsEXT\0");
3007 let val = _f(cname);
3008 if val.is_null() {
3009 get_calibrated_timestamps_ext
3010 } else {
3011 ::core::mem::transmute(val)
3012 }
3013 },
3014 }
3015 }
3016 }
3017 }
3018 #[doc = "VK_EXT_vertex_attribute_divisor"]
3019 pub mod vertex_attribute_divisor {
3020 use super::super::*;
3021 pub use {
3022 crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_NAME as NAME,
3023 crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION as SPEC_VERSION,
3024 };
3025 }
3026 #[doc = "VK_EXT_pipeline_creation_feedback"]
3027 pub mod pipeline_creation_feedback {
3028 use super::super::*;
3029 pub use {
3030 crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_NAME as NAME,
3031 crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
3032 };
3033 }
3034 #[doc = "VK_EXT_pci_bus_info"]
3035 pub mod pci_bus_info {
3036 use super::super::*;
3037 pub use {
3038 crate::vk::EXT_PCI_BUS_INFO_NAME as NAME,
3039 crate::vk::EXT_PCI_BUS_INFO_SPEC_VERSION as SPEC_VERSION,
3040 };
3041 }
3042 #[doc = "VK_EXT_metal_surface"]
3043 pub mod metal_surface {
3044 use super::super::*;
3045 pub use {
3046 crate::vk::EXT_METAL_SURFACE_NAME as NAME,
3047 crate::vk::EXT_METAL_SURFACE_SPEC_VERSION as SPEC_VERSION,
3048 };
3049 #[doc = "VK_EXT_metal_surface instance-level functions"]
3050 #[derive(Clone)]
3051 pub struct Instance {
3052 pub(crate) fp: InstanceFn,
3053 pub(crate) handle: crate::vk::Instance,
3054 }
3055 impl Instance {
3056 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
3057 let handle = instance.handle();
3058 let fp = InstanceFn::load(|name| unsafe {
3059 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
3060 });
3061 Self { handle, fp }
3062 }
3063 #[inline]
3064 pub fn fp(&self) -> &InstanceFn {
3065 &self.fp
3066 }
3067 #[inline]
3068 pub fn instance(&self) -> crate::vk::Instance {
3069 self.handle
3070 }
3071 }
3072 #[derive(Clone)]
3073 #[doc = "Raw VK_EXT_metal_surface instance-level function pointers"]
3074 pub struct InstanceFn {
3075 pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT,
3076 }
3077 unsafe impl Send for InstanceFn {}
3078 unsafe impl Sync for InstanceFn {}
3079 impl InstanceFn {
3080 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3081 Self::load_erased(&mut f)
3082 }
3083 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3084 Self {
3085 create_metal_surface_ext: unsafe {
3086 unsafe extern "system" fn create_metal_surface_ext(
3087 _instance: crate::vk::Instance,
3088 _p_create_info: *const MetalSurfaceCreateInfoEXT<'_>,
3089 _p_allocator: *const AllocationCallbacks<'_>,
3090 _p_surface: *mut SurfaceKHR,
3091 ) -> Result {
3092 panic!(concat!(
3093 "Unable to load ",
3094 stringify!(create_metal_surface_ext)
3095 ))
3096 }
3097 let cname =
3098 CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0");
3099 let val = _f(cname);
3100 if val.is_null() {
3101 create_metal_surface_ext
3102 } else {
3103 ::core::mem::transmute(val)
3104 }
3105 },
3106 }
3107 }
3108 }
3109 }
3110 #[doc = "VK_EXT_fragment_density_map"]
3111 pub mod fragment_density_map {
3112 use super::super::*;
3113 pub use {
3114 crate::vk::EXT_FRAGMENT_DENSITY_MAP_NAME as NAME,
3115 crate::vk::EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION as SPEC_VERSION,
3116 };
3117 }
3118 #[doc = "VK_EXT_scalar_block_layout"]
3119 pub mod scalar_block_layout {
3120 use super::super::*;
3121 pub use {
3122 crate::vk::EXT_SCALAR_BLOCK_LAYOUT_NAME as NAME,
3123 crate::vk::EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION as SPEC_VERSION,
3124 };
3125 }
3126 #[doc = "VK_EXT_subgroup_size_control"]
3127 pub mod subgroup_size_control {
3128 use super::super::*;
3129 pub use {
3130 crate::vk::EXT_SUBGROUP_SIZE_CONTROL_NAME as NAME,
3131 crate::vk::EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION as SPEC_VERSION,
3132 };
3133 }
3134 #[doc = "VK_EXT_shader_image_atomic_int64"]
3135 pub mod shader_image_atomic_int64 {
3136 use super::super::*;
3137 pub use {
3138 crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_NAME as NAME,
3139 crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION as SPEC_VERSION,
3140 };
3141 }
3142 #[doc = "VK_EXT_memory_budget"]
3143 pub mod memory_budget {
3144 use super::super::*;
3145 pub use {
3146 crate::vk::EXT_MEMORY_BUDGET_NAME as NAME,
3147 crate::vk::EXT_MEMORY_BUDGET_SPEC_VERSION as SPEC_VERSION,
3148 };
3149 }
3150 #[doc = "VK_EXT_memory_priority"]
3151 pub mod memory_priority {
3152 use super::super::*;
3153 pub use {
3154 crate::vk::EXT_MEMORY_PRIORITY_NAME as NAME,
3155 crate::vk::EXT_MEMORY_PRIORITY_SPEC_VERSION as SPEC_VERSION,
3156 };
3157 }
3158 #[doc = "VK_EXT_buffer_device_address"]
3159 pub mod buffer_device_address {
3160 use super::super::*;
3161 pub use {
3162 crate::vk::EXT_BUFFER_DEVICE_ADDRESS_NAME as NAME,
3163 crate::vk::EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION as SPEC_VERSION,
3164 };
3165 #[doc = "VK_EXT_buffer_device_address device-level functions"]
3166 #[derive(Clone)]
3167 pub struct Device {
3168 pub(crate) fp: DeviceFn,
3169 pub(crate) handle: crate::vk::Device,
3170 }
3171 impl Device {
3172 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
3173 let handle = device.handle();
3174 let fp = DeviceFn::load(|name| unsafe {
3175 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
3176 });
3177 Self { handle, fp }
3178 }
3179 #[inline]
3180 pub fn fp(&self) -> &DeviceFn {
3181 &self.fp
3182 }
3183 #[inline]
3184 pub fn device(&self) -> crate::vk::Device {
3185 self.handle
3186 }
3187 }
3188 #[derive(Clone)]
3189 #[doc = "Raw VK_EXT_buffer_device_address device-level function pointers"]
3190 pub struct DeviceFn {
3191 pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress,
3192 }
3193 unsafe impl Send for DeviceFn {}
3194 unsafe impl Sync for DeviceFn {}
3195 impl DeviceFn {
3196 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3197 Self::load_erased(&mut f)
3198 }
3199 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3200 Self {
3201 get_buffer_device_address_ext: unsafe {
3202 unsafe extern "system" fn get_buffer_device_address_ext(
3203 _device: crate::vk::Device,
3204 _p_info: *const BufferDeviceAddressInfo<'_>,
3205 ) -> DeviceAddress {
3206 panic!(concat!(
3207 "Unable to load ",
3208 stringify!(get_buffer_device_address_ext)
3209 ))
3210 }
3211 let cname =
3212 CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddressEXT\0");
3213 let val = _f(cname);
3214 if val.is_null() {
3215 get_buffer_device_address_ext
3216 } else {
3217 ::core::mem::transmute(val)
3218 }
3219 },
3220 }
3221 }
3222 }
3223 }
3224 #[doc = "VK_EXT_tooling_info"]
3225 pub mod tooling_info {
3226 use super::super::*;
3227 pub use {
3228 crate::vk::EXT_TOOLING_INFO_NAME as NAME,
3229 crate::vk::EXT_TOOLING_INFO_SPEC_VERSION as SPEC_VERSION,
3230 };
3231 #[doc = "VK_EXT_tooling_info instance-level functions"]
3232 #[derive(Clone)]
3233 pub struct Instance {
3234 pub(crate) fp: InstanceFn,
3235 pub(crate) handle: crate::vk::Instance,
3236 }
3237 impl Instance {
3238 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
3239 let handle = instance.handle();
3240 let fp = InstanceFn::load(|name| unsafe {
3241 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
3242 });
3243 Self { handle, fp }
3244 }
3245 #[inline]
3246 pub fn fp(&self) -> &InstanceFn {
3247 &self.fp
3248 }
3249 #[inline]
3250 pub fn instance(&self) -> crate::vk::Instance {
3251 self.handle
3252 }
3253 }
3254 #[derive(Clone)]
3255 #[doc = "Raw VK_EXT_tooling_info instance-level function pointers"]
3256 pub struct InstanceFn {
3257 pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties,
3258 }
3259 unsafe impl Send for InstanceFn {}
3260 unsafe impl Sync for InstanceFn {}
3261 impl InstanceFn {
3262 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3263 Self::load_erased(&mut f)
3264 }
3265 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3266 Self {
3267 get_physical_device_tool_properties_ext: unsafe {
3268 unsafe extern "system" fn get_physical_device_tool_properties_ext(
3269 _physical_device: PhysicalDevice,
3270 _p_tool_count: *mut u32,
3271 _p_tool_properties: *mut PhysicalDeviceToolProperties<'_>,
3272 ) -> Result {
3273 panic!(concat!(
3274 "Unable to load ",
3275 stringify!(get_physical_device_tool_properties_ext)
3276 ))
3277 }
3278 let cname = CStr::from_bytes_with_nul_unchecked(
3279 b"vkGetPhysicalDeviceToolPropertiesEXT\0",
3280 );
3281 let val = _f(cname);
3282 if val.is_null() {
3283 get_physical_device_tool_properties_ext
3284 } else {
3285 ::core::mem::transmute(val)
3286 }
3287 },
3288 }
3289 }
3290 }
3291 }
3292 #[doc = "VK_EXT_separate_stencil_usage"]
3293 pub mod separate_stencil_usage {
3294 use super::super::*;
3295 pub use {
3296 crate::vk::EXT_SEPARATE_STENCIL_USAGE_NAME as NAME,
3297 crate::vk::EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION as SPEC_VERSION,
3298 };
3299 }
3300 #[doc = "VK_EXT_validation_features"]
3301 pub mod validation_features {
3302 use super::super::*;
3303 pub use {
3304 crate::vk::EXT_VALIDATION_FEATURES_NAME as NAME,
3305 crate::vk::EXT_VALIDATION_FEATURES_SPEC_VERSION as SPEC_VERSION,
3306 };
3307 }
3308 #[doc = "VK_EXT_fragment_shader_interlock"]
3309 pub mod fragment_shader_interlock {
3310 use super::super::*;
3311 pub use {
3312 crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_NAME as NAME,
3313 crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION as SPEC_VERSION,
3314 };
3315 }
3316 #[doc = "VK_EXT_ycbcr_image_arrays"]
3317 pub mod ycbcr_image_arrays {
3318 use super::super::*;
3319 pub use {
3320 crate::vk::EXT_YCBCR_IMAGE_ARRAYS_NAME as NAME,
3321 crate::vk::EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION as SPEC_VERSION,
3322 };
3323 }
3324 #[doc = "VK_EXT_provoking_vertex"]
3325 pub mod provoking_vertex {
3326 use super::super::*;
3327 pub use {
3328 crate::vk::EXT_PROVOKING_VERTEX_NAME as NAME,
3329 crate::vk::EXT_PROVOKING_VERTEX_SPEC_VERSION as SPEC_VERSION,
3330 };
3331 }
3332 #[doc = "VK_EXT_full_screen_exclusive"]
3333 pub mod full_screen_exclusive {
3334 use super::super::*;
3335 pub use {
3336 crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_NAME as NAME,
3337 crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION as SPEC_VERSION,
3338 };
3339 #[doc = "VK_EXT_full_screen_exclusive instance-level functions"]
3340 #[derive(Clone)]
3341 pub struct Instance {
3342 pub(crate) fp: InstanceFn,
3343 pub(crate) handle: crate::vk::Instance,
3344 }
3345 impl Instance {
3346 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
3347 let handle = instance.handle();
3348 let fp = InstanceFn::load(|name| unsafe {
3349 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
3350 });
3351 Self { handle, fp }
3352 }
3353 #[inline]
3354 pub fn fp(&self) -> &InstanceFn {
3355 &self.fp
3356 }
3357 #[inline]
3358 pub fn instance(&self) -> crate::vk::Instance {
3359 self.handle
3360 }
3361 }
3362 #[derive(Clone)]
3363 #[doc = "Raw VK_EXT_full_screen_exclusive instance-level function pointers"]
3364 pub struct InstanceFn {
3365 pub get_physical_device_surface_present_modes2_ext:
3366 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
3367 }
3368 unsafe impl Send for InstanceFn {}
3369 unsafe impl Sync for InstanceFn {}
3370 impl InstanceFn {
3371 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3372 Self::load_erased(&mut f)
3373 }
3374 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3375 Self {
3376 get_physical_device_surface_present_modes2_ext: unsafe {
3377 unsafe extern "system" fn get_physical_device_surface_present_modes2_ext(
3378 _physical_device: PhysicalDevice,
3379 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
3380 _p_present_mode_count: *mut u32,
3381 _p_present_modes: *mut PresentModeKHR,
3382 ) -> Result {
3383 panic!(concat!(
3384 "Unable to load ",
3385 stringify!(get_physical_device_surface_present_modes2_ext)
3386 ))
3387 }
3388 let cname = CStr::from_bytes_with_nul_unchecked(
3389 b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0",
3390 );
3391 let val = _f(cname);
3392 if val.is_null() {
3393 get_physical_device_surface_present_modes2_ext
3394 } else {
3395 ::core::mem::transmute(val)
3396 }
3397 },
3398 }
3399 }
3400 }
3401 #[doc = "VK_EXT_full_screen_exclusive device-level functions"]
3402 #[derive(Clone)]
3403 pub struct Device {
3404 pub(crate) fp: DeviceFn,
3405 pub(crate) handle: crate::vk::Device,
3406 }
3407 impl Device {
3408 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
3409 let handle = device.handle();
3410 let fp = DeviceFn::load(|name| unsafe {
3411 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
3412 });
3413 Self { handle, fp }
3414 }
3415 #[inline]
3416 pub fn fp(&self) -> &DeviceFn {
3417 &self.fp
3418 }
3419 #[inline]
3420 pub fn device(&self) -> crate::vk::Device {
3421 self.handle
3422 }
3423 }
3424 #[derive(Clone)]
3425 #[doc = "Raw VK_EXT_full_screen_exclusive device-level function pointers"]
3426 pub struct DeviceFn {
3427 pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEXT,
3428 pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEXT,
3429 pub get_device_group_surface_present_modes2_ext:
3430 PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
3431 }
3432 unsafe impl Send for DeviceFn {}
3433 unsafe impl Sync for DeviceFn {}
3434 impl DeviceFn {
3435 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3436 Self::load_erased(&mut f)
3437 }
3438 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3439 Self {
3440 acquire_full_screen_exclusive_mode_ext: unsafe {
3441 unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext(
3442 _device: crate::vk::Device,
3443 _swapchain: SwapchainKHR,
3444 ) -> Result {
3445 panic!(concat!(
3446 "Unable to load ",
3447 stringify!(acquire_full_screen_exclusive_mode_ext)
3448 ))
3449 }
3450 let cname = CStr::from_bytes_with_nul_unchecked(
3451 b"vkAcquireFullScreenExclusiveModeEXT\0",
3452 );
3453 let val = _f(cname);
3454 if val.is_null() {
3455 acquire_full_screen_exclusive_mode_ext
3456 } else {
3457 ::core::mem::transmute(val)
3458 }
3459 },
3460 release_full_screen_exclusive_mode_ext: unsafe {
3461 unsafe extern "system" fn release_full_screen_exclusive_mode_ext(
3462 _device: crate::vk::Device,
3463 _swapchain: SwapchainKHR,
3464 ) -> Result {
3465 panic!(concat!(
3466 "Unable to load ",
3467 stringify!(release_full_screen_exclusive_mode_ext)
3468 ))
3469 }
3470 let cname = CStr::from_bytes_with_nul_unchecked(
3471 b"vkReleaseFullScreenExclusiveModeEXT\0",
3472 );
3473 let val = _f(cname);
3474 if val.is_null() {
3475 release_full_screen_exclusive_mode_ext
3476 } else {
3477 ::core::mem::transmute(val)
3478 }
3479 },
3480 get_device_group_surface_present_modes2_ext: unsafe {
3481 unsafe extern "system" fn get_device_group_surface_present_modes2_ext(
3482 _device: crate::vk::Device,
3483 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
3484 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
3485 ) -> Result {
3486 panic!(concat!(
3487 "Unable to load ",
3488 stringify!(get_device_group_surface_present_modes2_ext)
3489 ))
3490 }
3491 let cname = CStr::from_bytes_with_nul_unchecked(
3492 b"vkGetDeviceGroupSurfacePresentModes2EXT\0",
3493 );
3494 let val = _f(cname);
3495 if val.is_null() {
3496 get_device_group_surface_present_modes2_ext
3497 } else {
3498 ::core::mem::transmute(val)
3499 }
3500 },
3501 }
3502 }
3503 }
3504 }
3505 #[doc = "VK_EXT_headless_surface"]
3506 pub mod headless_surface {
3507 use super::super::*;
3508 pub use {
3509 crate::vk::EXT_HEADLESS_SURFACE_NAME as NAME,
3510 crate::vk::EXT_HEADLESS_SURFACE_SPEC_VERSION as SPEC_VERSION,
3511 };
3512 #[doc = "VK_EXT_headless_surface instance-level functions"]
3513 #[derive(Clone)]
3514 pub struct Instance {
3515 pub(crate) fp: InstanceFn,
3516 pub(crate) handle: crate::vk::Instance,
3517 }
3518 impl Instance {
3519 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
3520 let handle = instance.handle();
3521 let fp = InstanceFn::load(|name| unsafe {
3522 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
3523 });
3524 Self { handle, fp }
3525 }
3526 #[inline]
3527 pub fn fp(&self) -> &InstanceFn {
3528 &self.fp
3529 }
3530 #[inline]
3531 pub fn instance(&self) -> crate::vk::Instance {
3532 self.handle
3533 }
3534 }
3535 #[derive(Clone)]
3536 #[doc = "Raw VK_EXT_headless_surface instance-level function pointers"]
3537 pub struct InstanceFn {
3538 pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT,
3539 }
3540 unsafe impl Send for InstanceFn {}
3541 unsafe impl Sync for InstanceFn {}
3542 impl InstanceFn {
3543 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3544 Self::load_erased(&mut f)
3545 }
3546 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3547 Self {
3548 create_headless_surface_ext: unsafe {
3549 unsafe extern "system" fn create_headless_surface_ext(
3550 _instance: crate::vk::Instance,
3551 _p_create_info: *const HeadlessSurfaceCreateInfoEXT<'_>,
3552 _p_allocator: *const AllocationCallbacks<'_>,
3553 _p_surface: *mut SurfaceKHR,
3554 ) -> Result {
3555 panic!(concat!(
3556 "Unable to load ",
3557 stringify!(create_headless_surface_ext)
3558 ))
3559 }
3560 let cname =
3561 CStr::from_bytes_with_nul_unchecked(b"vkCreateHeadlessSurfaceEXT\0");
3562 let val = _f(cname);
3563 if val.is_null() {
3564 create_headless_surface_ext
3565 } else {
3566 ::core::mem::transmute(val)
3567 }
3568 },
3569 }
3570 }
3571 }
3572 }
3573 #[doc = "VK_EXT_line_rasterization"]
3574 pub mod line_rasterization {
3575 use super::super::*;
3576 pub use {
3577 crate::vk::EXT_LINE_RASTERIZATION_NAME as NAME,
3578 crate::vk::EXT_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
3579 };
3580 #[doc = "VK_EXT_line_rasterization device-level functions"]
3581 #[derive(Clone)]
3582 pub struct Device {
3583 pub(crate) fp: DeviceFn,
3584 pub(crate) handle: crate::vk::Device,
3585 }
3586 impl Device {
3587 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
3588 let handle = device.handle();
3589 let fp = DeviceFn::load(|name| unsafe {
3590 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
3591 });
3592 Self { handle, fp }
3593 }
3594 #[inline]
3595 pub fn fp(&self) -> &DeviceFn {
3596 &self.fp
3597 }
3598 #[inline]
3599 pub fn device(&self) -> crate::vk::Device {
3600 self.handle
3601 }
3602 }
3603 #[derive(Clone)]
3604 #[doc = "Raw VK_EXT_line_rasterization device-level function pointers"]
3605 pub struct DeviceFn {
3606 pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleKHR,
3607 }
3608 unsafe impl Send for DeviceFn {}
3609 unsafe impl Sync for DeviceFn {}
3610 impl DeviceFn {
3611 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3612 Self::load_erased(&mut f)
3613 }
3614 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3615 Self {
3616 cmd_set_line_stipple_ext: unsafe {
3617 unsafe extern "system" fn cmd_set_line_stipple_ext(
3618 _command_buffer: CommandBuffer,
3619 _line_stipple_factor: u32,
3620 _line_stipple_pattern: u16,
3621 ) {
3622 panic!(concat!(
3623 "Unable to load ",
3624 stringify!(cmd_set_line_stipple_ext)
3625 ))
3626 }
3627 let cname =
3628 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0");
3629 let val = _f(cname);
3630 if val.is_null() {
3631 cmd_set_line_stipple_ext
3632 } else {
3633 ::core::mem::transmute(val)
3634 }
3635 },
3636 }
3637 }
3638 }
3639 }
3640 #[doc = "VK_EXT_shader_atomic_float"]
3641 pub mod shader_atomic_float {
3642 use super::super::*;
3643 pub use {
3644 crate::vk::EXT_SHADER_ATOMIC_FLOAT_NAME as NAME,
3645 crate::vk::EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION as SPEC_VERSION,
3646 };
3647 }
3648 #[doc = "VK_EXT_host_query_reset"]
3649 pub mod host_query_reset {
3650 use super::super::*;
3651 pub use {
3652 crate::vk::EXT_HOST_QUERY_RESET_NAME as NAME,
3653 crate::vk::EXT_HOST_QUERY_RESET_SPEC_VERSION as SPEC_VERSION,
3654 };
3655 #[doc = "VK_EXT_host_query_reset device-level functions"]
3656 #[derive(Clone)]
3657 pub struct Device {
3658 pub(crate) fp: DeviceFn,
3659 pub(crate) handle: crate::vk::Device,
3660 }
3661 impl Device {
3662 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
3663 let handle = device.handle();
3664 let fp = DeviceFn::load(|name| unsafe {
3665 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
3666 });
3667 Self { handle, fp }
3668 }
3669 #[inline]
3670 pub fn fp(&self) -> &DeviceFn {
3671 &self.fp
3672 }
3673 #[inline]
3674 pub fn device(&self) -> crate::vk::Device {
3675 self.handle
3676 }
3677 }
3678 #[derive(Clone)]
3679 #[doc = "Raw VK_EXT_host_query_reset device-level function pointers"]
3680 pub struct DeviceFn {
3681 pub reset_query_pool_ext: PFN_vkResetQueryPool,
3682 }
3683 unsafe impl Send for DeviceFn {}
3684 unsafe impl Sync for DeviceFn {}
3685 impl DeviceFn {
3686 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3687 Self::load_erased(&mut f)
3688 }
3689 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3690 Self {
3691 reset_query_pool_ext: unsafe {
3692 unsafe extern "system" fn reset_query_pool_ext(
3693 _device: crate::vk::Device,
3694 _query_pool: QueryPool,
3695 _first_query: u32,
3696 _query_count: u32,
3697 ) {
3698 panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext)))
3699 }
3700 let cname = CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0");
3701 let val = _f(cname);
3702 if val.is_null() {
3703 reset_query_pool_ext
3704 } else {
3705 ::core::mem::transmute(val)
3706 }
3707 },
3708 }
3709 }
3710 }
3711 }
3712 #[doc = "VK_EXT_index_type_uint8"]
3713 pub mod index_type_uint8 {
3714 use super::super::*;
3715 pub use {
3716 crate::vk::EXT_INDEX_TYPE_UINT8_NAME as NAME,
3717 crate::vk::EXT_INDEX_TYPE_UINT8_SPEC_VERSION as SPEC_VERSION,
3718 };
3719 }
3720 #[doc = "VK_EXT_extended_dynamic_state"]
3721 pub mod extended_dynamic_state {
3722 use super::super::*;
3723 pub use {
3724 crate::vk::EXT_EXTENDED_DYNAMIC_STATE_NAME as NAME,
3725 crate::vk::EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
3726 };
3727 #[doc = "VK_EXT_extended_dynamic_state device-level functions"]
3728 #[derive(Clone)]
3729 pub struct Device {
3730 pub(crate) fp: DeviceFn,
3731 pub(crate) handle: crate::vk::Device,
3732 }
3733 impl Device {
3734 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
3735 let handle = device.handle();
3736 let fp = DeviceFn::load(|name| unsafe {
3737 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
3738 });
3739 Self { handle, fp }
3740 }
3741 #[inline]
3742 pub fn fp(&self) -> &DeviceFn {
3743 &self.fp
3744 }
3745 #[inline]
3746 pub fn device(&self) -> crate::vk::Device {
3747 self.handle
3748 }
3749 }
3750 #[derive(Clone)]
3751 #[doc = "Raw VK_EXT_extended_dynamic_state device-level function pointers"]
3752 pub struct DeviceFn {
3753 pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode,
3754 pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace,
3755 pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology,
3756 pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount,
3757 pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount,
3758 pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2,
3759 pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable,
3760 pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable,
3761 pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp,
3762 pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable,
3763 pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable,
3764 pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp,
3765 }
3766 unsafe impl Send for DeviceFn {}
3767 unsafe impl Sync for DeviceFn {}
3768 impl DeviceFn {
3769 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
3770 Self::load_erased(&mut f)
3771 }
3772 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
3773 Self {
3774 cmd_set_cull_mode_ext: unsafe {
3775 unsafe extern "system" fn cmd_set_cull_mode_ext(
3776 _command_buffer: CommandBuffer,
3777 _cull_mode: CullModeFlags,
3778 ) {
3779 panic!(concat!(
3780 "Unable to load ",
3781 stringify!(cmd_set_cull_mode_ext)
3782 ))
3783 }
3784 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
3785 let val = _f(cname);
3786 if val.is_null() {
3787 cmd_set_cull_mode_ext
3788 } else {
3789 ::core::mem::transmute(val)
3790 }
3791 },
3792 cmd_set_front_face_ext: unsafe {
3793 unsafe extern "system" fn cmd_set_front_face_ext(
3794 _command_buffer: CommandBuffer,
3795 _front_face: FrontFace,
3796 ) {
3797 panic!(concat!(
3798 "Unable to load ",
3799 stringify!(cmd_set_front_face_ext)
3800 ))
3801 }
3802 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
3803 let val = _f(cname);
3804 if val.is_null() {
3805 cmd_set_front_face_ext
3806 } else {
3807 ::core::mem::transmute(val)
3808 }
3809 },
3810 cmd_set_primitive_topology_ext: unsafe {
3811 unsafe extern "system" fn cmd_set_primitive_topology_ext(
3812 _command_buffer: CommandBuffer,
3813 _primitive_topology: PrimitiveTopology,
3814 ) {
3815 panic!(concat!(
3816 "Unable to load ",
3817 stringify!(cmd_set_primitive_topology_ext)
3818 ))
3819 }
3820 let cname =
3821 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0");
3822 let val = _f(cname);
3823 if val.is_null() {
3824 cmd_set_primitive_topology_ext
3825 } else {
3826 ::core::mem::transmute(val)
3827 }
3828 },
3829 cmd_set_viewport_with_count_ext: unsafe {
3830 unsafe extern "system" fn cmd_set_viewport_with_count_ext(
3831 _command_buffer: CommandBuffer,
3832 _viewport_count: u32,
3833 _p_viewports: *const Viewport,
3834 ) {
3835 panic!(concat!(
3836 "Unable to load ",
3837 stringify!(cmd_set_viewport_with_count_ext)
3838 ))
3839 }
3840 let cname =
3841 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0");
3842 let val = _f(cname);
3843 if val.is_null() {
3844 cmd_set_viewport_with_count_ext
3845 } else {
3846 ::core::mem::transmute(val)
3847 }
3848 },
3849 cmd_set_scissor_with_count_ext: unsafe {
3850 unsafe extern "system" fn cmd_set_scissor_with_count_ext(
3851 _command_buffer: CommandBuffer,
3852 _scissor_count: u32,
3853 _p_scissors: *const Rect2D,
3854 ) {
3855 panic!(concat!(
3856 "Unable to load ",
3857 stringify!(cmd_set_scissor_with_count_ext)
3858 ))
3859 }
3860 let cname =
3861 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0");
3862 let val = _f(cname);
3863 if val.is_null() {
3864 cmd_set_scissor_with_count_ext
3865 } else {
3866 ::core::mem::transmute(val)
3867 }
3868 },
3869 cmd_bind_vertex_buffers2_ext: unsafe {
3870 unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
3871 _command_buffer: CommandBuffer,
3872 _first_binding: u32,
3873 _binding_count: u32,
3874 _p_buffers: *const Buffer,
3875 _p_offsets: *const DeviceSize,
3876 _p_sizes: *const DeviceSize,
3877 _p_strides: *const DeviceSize,
3878 ) {
3879 panic!(concat!(
3880 "Unable to load ",
3881 stringify!(cmd_bind_vertex_buffers2_ext)
3882 ))
3883 }
3884 let cname =
3885 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0");
3886 let val = _f(cname);
3887 if val.is_null() {
3888 cmd_bind_vertex_buffers2_ext
3889 } else {
3890 ::core::mem::transmute(val)
3891 }
3892 },
3893 cmd_set_depth_test_enable_ext: unsafe {
3894 unsafe extern "system" fn cmd_set_depth_test_enable_ext(
3895 _command_buffer: CommandBuffer,
3896 _depth_test_enable: Bool32,
3897 ) {
3898 panic!(concat!(
3899 "Unable to load ",
3900 stringify!(cmd_set_depth_test_enable_ext)
3901 ))
3902 }
3903 let cname =
3904 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0");
3905 let val = _f(cname);
3906 if val.is_null() {
3907 cmd_set_depth_test_enable_ext
3908 } else {
3909 ::core::mem::transmute(val)
3910 }
3911 },
3912 cmd_set_depth_write_enable_ext: unsafe {
3913 unsafe extern "system" fn cmd_set_depth_write_enable_ext(
3914 _command_buffer: CommandBuffer,
3915 _depth_write_enable: Bool32,
3916 ) {
3917 panic!(concat!(
3918 "Unable to load ",
3919 stringify!(cmd_set_depth_write_enable_ext)
3920 ))
3921 }
3922 let cname =
3923 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0");
3924 let val = _f(cname);
3925 if val.is_null() {
3926 cmd_set_depth_write_enable_ext
3927 } else {
3928 ::core::mem::transmute(val)
3929 }
3930 },
3931 cmd_set_depth_compare_op_ext: unsafe {
3932 unsafe extern "system" fn cmd_set_depth_compare_op_ext(
3933 _command_buffer: CommandBuffer,
3934 _depth_compare_op: CompareOp,
3935 ) {
3936 panic!(concat!(
3937 "Unable to load ",
3938 stringify!(cmd_set_depth_compare_op_ext)
3939 ))
3940 }
3941 let cname =
3942 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
3943 let val = _f(cname);
3944 if val.is_null() {
3945 cmd_set_depth_compare_op_ext
3946 } else {
3947 ::core::mem::transmute(val)
3948 }
3949 },
3950 cmd_set_depth_bounds_test_enable_ext: unsafe {
3951 unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
3952 _command_buffer: CommandBuffer,
3953 _depth_bounds_test_enable: Bool32,
3954 ) {
3955 panic!(concat!(
3956 "Unable to load ",
3957 stringify!(cmd_set_depth_bounds_test_enable_ext)
3958 ))
3959 }
3960 let cname = CStr::from_bytes_with_nul_unchecked(
3961 b"vkCmdSetDepthBoundsTestEnableEXT\0",
3962 );
3963 let val = _f(cname);
3964 if val.is_null() {
3965 cmd_set_depth_bounds_test_enable_ext
3966 } else {
3967 ::core::mem::transmute(val)
3968 }
3969 },
3970 cmd_set_stencil_test_enable_ext: unsafe {
3971 unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
3972 _command_buffer: CommandBuffer,
3973 _stencil_test_enable: Bool32,
3974 ) {
3975 panic!(concat!(
3976 "Unable to load ",
3977 stringify!(cmd_set_stencil_test_enable_ext)
3978 ))
3979 }
3980 let cname =
3981 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0");
3982 let val = _f(cname);
3983 if val.is_null() {
3984 cmd_set_stencil_test_enable_ext
3985 } else {
3986 ::core::mem::transmute(val)
3987 }
3988 },
3989 cmd_set_stencil_op_ext: unsafe {
3990 unsafe extern "system" fn cmd_set_stencil_op_ext(
3991 _command_buffer: CommandBuffer,
3992 _face_mask: StencilFaceFlags,
3993 _fail_op: StencilOp,
3994 _pass_op: StencilOp,
3995 _depth_fail_op: StencilOp,
3996 _compare_op: CompareOp,
3997 ) {
3998 panic!(concat!(
3999 "Unable to load ",
4000 stringify!(cmd_set_stencil_op_ext)
4001 ))
4002 }
4003 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
4004 let val = _f(cname);
4005 if val.is_null() {
4006 cmd_set_stencil_op_ext
4007 } else {
4008 ::core::mem::transmute(val)
4009 }
4010 },
4011 }
4012 }
4013 }
4014 }
4015 #[doc = "VK_EXT_host_image_copy"]
4016 pub mod host_image_copy {
4017 use super::super::*;
4018 pub use {
4019 crate::vk::EXT_HOST_IMAGE_COPY_NAME as NAME,
4020 crate::vk::EXT_HOST_IMAGE_COPY_SPEC_VERSION as SPEC_VERSION,
4021 };
4022 #[doc = "VK_EXT_host_image_copy device-level functions"]
4023 #[derive(Clone)]
4024 pub struct Device {
4025 pub(crate) fp: DeviceFn,
4026 pub(crate) handle: crate::vk::Device,
4027 }
4028 impl Device {
4029 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4030 let handle = device.handle();
4031 let fp = DeviceFn::load(|name| unsafe {
4032 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4033 });
4034 Self { handle, fp }
4035 }
4036 #[inline]
4037 pub fn fp(&self) -> &DeviceFn {
4038 &self.fp
4039 }
4040 #[inline]
4041 pub fn device(&self) -> crate::vk::Device {
4042 self.handle
4043 }
4044 }
4045 #[derive(Clone)]
4046 #[doc = "Raw VK_EXT_host_image_copy device-level function pointers"]
4047 pub struct DeviceFn {
4048 pub copy_memory_to_image_ext: PFN_vkCopyMemoryToImageEXT,
4049 pub copy_image_to_memory_ext: PFN_vkCopyImageToMemoryEXT,
4050 pub copy_image_to_image_ext: PFN_vkCopyImageToImageEXT,
4051 pub transition_image_layout_ext: PFN_vkTransitionImageLayoutEXT,
4052 pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR,
4053 }
4054 unsafe impl Send for DeviceFn {}
4055 unsafe impl Sync for DeviceFn {}
4056 impl DeviceFn {
4057 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4058 Self::load_erased(&mut f)
4059 }
4060 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4061 Self {
4062 copy_memory_to_image_ext: unsafe {
4063 unsafe extern "system" fn copy_memory_to_image_ext(
4064 _device: crate::vk::Device,
4065 _p_copy_memory_to_image_info: *const CopyMemoryToImageInfoEXT<'_>,
4066 ) -> Result {
4067 panic!(concat!(
4068 "Unable to load ",
4069 stringify!(copy_memory_to_image_ext)
4070 ))
4071 }
4072 let cname =
4073 CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToImageEXT\0");
4074 let val = _f(cname);
4075 if val.is_null() {
4076 copy_memory_to_image_ext
4077 } else {
4078 ::core::mem::transmute(val)
4079 }
4080 },
4081 copy_image_to_memory_ext: unsafe {
4082 unsafe extern "system" fn copy_image_to_memory_ext(
4083 _device: crate::vk::Device,
4084 _p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT<'_>,
4085 ) -> Result {
4086 panic!(concat!(
4087 "Unable to load ",
4088 stringify!(copy_image_to_memory_ext)
4089 ))
4090 }
4091 let cname =
4092 CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToMemoryEXT\0");
4093 let val = _f(cname);
4094 if val.is_null() {
4095 copy_image_to_memory_ext
4096 } else {
4097 ::core::mem::transmute(val)
4098 }
4099 },
4100 copy_image_to_image_ext: unsafe {
4101 unsafe extern "system" fn copy_image_to_image_ext(
4102 _device: crate::vk::Device,
4103 _p_copy_image_to_image_info: *const CopyImageToImageInfoEXT<'_>,
4104 ) -> Result {
4105 panic!(concat!(
4106 "Unable to load ",
4107 stringify!(copy_image_to_image_ext)
4108 ))
4109 }
4110 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToImageEXT\0");
4111 let val = _f(cname);
4112 if val.is_null() {
4113 copy_image_to_image_ext
4114 } else {
4115 ::core::mem::transmute(val)
4116 }
4117 },
4118 transition_image_layout_ext: unsafe {
4119 unsafe extern "system" fn transition_image_layout_ext(
4120 _device: crate::vk::Device,
4121 _transition_count: u32,
4122 _p_transitions: *const HostImageLayoutTransitionInfoEXT<'_>,
4123 ) -> Result {
4124 panic!(concat!(
4125 "Unable to load ",
4126 stringify!(transition_image_layout_ext)
4127 ))
4128 }
4129 let cname =
4130 CStr::from_bytes_with_nul_unchecked(b"vkTransitionImageLayoutEXT\0");
4131 let val = _f(cname);
4132 if val.is_null() {
4133 transition_image_layout_ext
4134 } else {
4135 ::core::mem::transmute(val)
4136 }
4137 },
4138 get_image_subresource_layout2_ext: unsafe {
4139 unsafe extern "system" fn get_image_subresource_layout2_ext(
4140 _device: crate::vk::Device,
4141 _image: Image,
4142 _p_subresource: *const ImageSubresource2KHR<'_>,
4143 _p_layout: *mut SubresourceLayout2KHR<'_>,
4144 ) {
4145 panic!(concat!(
4146 "Unable to load ",
4147 stringify!(get_image_subresource_layout2_ext)
4148 ))
4149 }
4150 let cname = CStr::from_bytes_with_nul_unchecked(
4151 b"vkGetImageSubresourceLayout2EXT\0",
4152 );
4153 let val = _f(cname);
4154 if val.is_null() {
4155 get_image_subresource_layout2_ext
4156 } else {
4157 ::core::mem::transmute(val)
4158 }
4159 },
4160 }
4161 }
4162 }
4163 }
4164 #[doc = "VK_EXT_map_memory_placed"]
4165 pub mod map_memory_placed {
4166 use super::super::*;
4167 pub use {
4168 crate::vk::EXT_MAP_MEMORY_PLACED_NAME as NAME,
4169 crate::vk::EXT_MAP_MEMORY_PLACED_SPEC_VERSION as SPEC_VERSION,
4170 };
4171 }
4172 #[doc = "VK_EXT_shader_atomic_float2"]
4173 pub mod shader_atomic_float2 {
4174 use super::super::*;
4175 pub use {
4176 crate::vk::EXT_SHADER_ATOMIC_FLOAT2_NAME as NAME,
4177 crate::vk::EXT_SHADER_ATOMIC_FLOAT2_SPEC_VERSION as SPEC_VERSION,
4178 };
4179 }
4180 #[doc = "VK_EXT_surface_maintenance1"]
4181 pub mod surface_maintenance1 {
4182 use super::super::*;
4183 pub use {
4184 crate::vk::EXT_SURFACE_MAINTENANCE1_NAME as NAME,
4185 crate::vk::EXT_SURFACE_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
4186 };
4187 }
4188 #[doc = "VK_EXT_swapchain_maintenance1"]
4189 pub mod swapchain_maintenance1 {
4190 use super::super::*;
4191 pub use {
4192 crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_NAME as NAME,
4193 crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
4194 };
4195 #[doc = "VK_EXT_swapchain_maintenance1 device-level functions"]
4196 #[derive(Clone)]
4197 pub struct Device {
4198 pub(crate) fp: DeviceFn,
4199 pub(crate) handle: crate::vk::Device,
4200 }
4201 impl Device {
4202 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4203 let handle = device.handle();
4204 let fp = DeviceFn::load(|name| unsafe {
4205 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4206 });
4207 Self { handle, fp }
4208 }
4209 #[inline]
4210 pub fn fp(&self) -> &DeviceFn {
4211 &self.fp
4212 }
4213 #[inline]
4214 pub fn device(&self) -> crate::vk::Device {
4215 self.handle
4216 }
4217 }
4218 #[derive(Clone)]
4219 #[doc = "Raw VK_EXT_swapchain_maintenance1 device-level function pointers"]
4220 pub struct DeviceFn {
4221 pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT,
4222 }
4223 unsafe impl Send for DeviceFn {}
4224 unsafe impl Sync for DeviceFn {}
4225 impl DeviceFn {
4226 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4227 Self::load_erased(&mut f)
4228 }
4229 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4230 Self {
4231 release_swapchain_images_ext: unsafe {
4232 unsafe extern "system" fn release_swapchain_images_ext(
4233 _device: crate::vk::Device,
4234 _p_release_info: *const ReleaseSwapchainImagesInfoEXT<'_>,
4235 ) -> Result {
4236 panic!(concat!(
4237 "Unable to load ",
4238 stringify!(release_swapchain_images_ext)
4239 ))
4240 }
4241 let cname =
4242 CStr::from_bytes_with_nul_unchecked(b"vkReleaseSwapchainImagesEXT\0");
4243 let val = _f(cname);
4244 if val.is_null() {
4245 release_swapchain_images_ext
4246 } else {
4247 ::core::mem::transmute(val)
4248 }
4249 },
4250 }
4251 }
4252 }
4253 }
4254 #[doc = "VK_EXT_shader_demote_to_helper_invocation"]
4255 pub mod shader_demote_to_helper_invocation {
4256 use super::super::*;
4257 pub use {
4258 crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_NAME as NAME,
4259 crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION as SPEC_VERSION,
4260 };
4261 }
4262 #[doc = "VK_EXT_texel_buffer_alignment"]
4263 pub mod texel_buffer_alignment {
4264 use super::super::*;
4265 pub use {
4266 crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_NAME as NAME,
4267 crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION as SPEC_VERSION,
4268 };
4269 }
4270 #[doc = "VK_EXT_depth_bias_control"]
4271 pub mod depth_bias_control {
4272 use super::super::*;
4273 pub use {
4274 crate::vk::EXT_DEPTH_BIAS_CONTROL_NAME as NAME,
4275 crate::vk::EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION as SPEC_VERSION,
4276 };
4277 #[doc = "VK_EXT_depth_bias_control device-level functions"]
4278 #[derive(Clone)]
4279 pub struct Device {
4280 pub(crate) fp: DeviceFn,
4281 pub(crate) handle: crate::vk::Device,
4282 }
4283 impl Device {
4284 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4285 let handle = device.handle();
4286 let fp = DeviceFn::load(|name| unsafe {
4287 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4288 });
4289 Self { handle, fp }
4290 }
4291 #[inline]
4292 pub fn fp(&self) -> &DeviceFn {
4293 &self.fp
4294 }
4295 #[inline]
4296 pub fn device(&self) -> crate::vk::Device {
4297 self.handle
4298 }
4299 }
4300 #[derive(Clone)]
4301 #[doc = "Raw VK_EXT_depth_bias_control device-level function pointers"]
4302 pub struct DeviceFn {
4303 pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT,
4304 }
4305 unsafe impl Send for DeviceFn {}
4306 unsafe impl Sync for DeviceFn {}
4307 impl DeviceFn {
4308 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4309 Self::load_erased(&mut f)
4310 }
4311 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4312 Self {
4313 cmd_set_depth_bias2_ext: unsafe {
4314 unsafe extern "system" fn cmd_set_depth_bias2_ext(
4315 _command_buffer: CommandBuffer,
4316 _p_depth_bias_info: *const DepthBiasInfoEXT<'_>,
4317 ) {
4318 panic!(concat!(
4319 "Unable to load ",
4320 stringify!(cmd_set_depth_bias2_ext)
4321 ))
4322 }
4323 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0");
4324 let val = _f(cname);
4325 if val.is_null() {
4326 cmd_set_depth_bias2_ext
4327 } else {
4328 ::core::mem::transmute(val)
4329 }
4330 },
4331 }
4332 }
4333 }
4334 }
4335 #[doc = "VK_EXT_device_memory_report"]
4336 pub mod device_memory_report {
4337 use super::super::*;
4338 pub use {
4339 crate::vk::EXT_DEVICE_MEMORY_REPORT_NAME as NAME,
4340 crate::vk::EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION as SPEC_VERSION,
4341 };
4342 }
4343 #[doc = "VK_EXT_acquire_drm_display"]
4344 pub mod acquire_drm_display {
4345 use super::super::*;
4346 pub use {
4347 crate::vk::EXT_ACQUIRE_DRM_DISPLAY_NAME as NAME,
4348 crate::vk::EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION as SPEC_VERSION,
4349 };
4350 #[doc = "VK_EXT_acquire_drm_display instance-level functions"]
4351 #[derive(Clone)]
4352 pub struct Instance {
4353 pub(crate) fp: InstanceFn,
4354 pub(crate) handle: crate::vk::Instance,
4355 }
4356 impl Instance {
4357 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
4358 let handle = instance.handle();
4359 let fp = InstanceFn::load(|name| unsafe {
4360 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
4361 });
4362 Self { handle, fp }
4363 }
4364 #[inline]
4365 pub fn fp(&self) -> &InstanceFn {
4366 &self.fp
4367 }
4368 #[inline]
4369 pub fn instance(&self) -> crate::vk::Instance {
4370 self.handle
4371 }
4372 }
4373 #[derive(Clone)]
4374 #[doc = "Raw VK_EXT_acquire_drm_display instance-level function pointers"]
4375 pub struct InstanceFn {
4376 pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT,
4377 pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT,
4378 }
4379 unsafe impl Send for InstanceFn {}
4380 unsafe impl Sync for InstanceFn {}
4381 impl InstanceFn {
4382 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4383 Self::load_erased(&mut f)
4384 }
4385 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4386 Self {
4387 acquire_drm_display_ext: unsafe {
4388 unsafe extern "system" fn acquire_drm_display_ext(
4389 _physical_device: PhysicalDevice,
4390 _drm_fd: i32,
4391 _display: DisplayKHR,
4392 ) -> Result {
4393 panic!(concat!(
4394 "Unable to load ",
4395 stringify!(acquire_drm_display_ext)
4396 ))
4397 }
4398 let cname =
4399 CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0");
4400 let val = _f(cname);
4401 if val.is_null() {
4402 acquire_drm_display_ext
4403 } else {
4404 ::core::mem::transmute(val)
4405 }
4406 },
4407 get_drm_display_ext: unsafe {
4408 unsafe extern "system" fn get_drm_display_ext(
4409 _physical_device: PhysicalDevice,
4410 _drm_fd: i32,
4411 _connector_id: u32,
4412 _display: *mut DisplayKHR,
4413 ) -> Result {
4414 panic!(concat!("Unable to load ", stringify!(get_drm_display_ext)))
4415 }
4416 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0");
4417 let val = _f(cname);
4418 if val.is_null() {
4419 get_drm_display_ext
4420 } else {
4421 ::core::mem::transmute(val)
4422 }
4423 },
4424 }
4425 }
4426 }
4427 }
4428 #[doc = "VK_EXT_robustness2"]
4429 pub mod robustness2 {
4430 use super::super::*;
4431 pub use {
4432 crate::vk::EXT_ROBUSTNESS2_NAME as NAME,
4433 crate::vk::EXT_ROBUSTNESS2_SPEC_VERSION as SPEC_VERSION,
4434 };
4435 }
4436 #[doc = "VK_EXT_custom_border_color"]
4437 pub mod custom_border_color {
4438 use super::super::*;
4439 pub use {
4440 crate::vk::EXT_CUSTOM_BORDER_COLOR_NAME as NAME,
4441 crate::vk::EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION as SPEC_VERSION,
4442 };
4443 }
4444 #[doc = "VK_EXT_private_data"]
4445 pub mod private_data {
4446 use super::super::*;
4447 pub use {
4448 crate::vk::EXT_PRIVATE_DATA_NAME as NAME,
4449 crate::vk::EXT_PRIVATE_DATA_SPEC_VERSION as SPEC_VERSION,
4450 };
4451 #[doc = "VK_EXT_private_data device-level functions"]
4452 #[derive(Clone)]
4453 pub struct Device {
4454 pub(crate) fp: DeviceFn,
4455 pub(crate) handle: crate::vk::Device,
4456 }
4457 impl Device {
4458 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4459 let handle = device.handle();
4460 let fp = DeviceFn::load(|name| unsafe {
4461 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4462 });
4463 Self { handle, fp }
4464 }
4465 #[inline]
4466 pub fn fp(&self) -> &DeviceFn {
4467 &self.fp
4468 }
4469 #[inline]
4470 pub fn device(&self) -> crate::vk::Device {
4471 self.handle
4472 }
4473 }
4474 #[derive(Clone)]
4475 #[doc = "Raw VK_EXT_private_data device-level function pointers"]
4476 pub struct DeviceFn {
4477 pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot,
4478 pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot,
4479 pub set_private_data_ext: PFN_vkSetPrivateData,
4480 pub get_private_data_ext: PFN_vkGetPrivateData,
4481 }
4482 unsafe impl Send for DeviceFn {}
4483 unsafe impl Sync for DeviceFn {}
4484 impl DeviceFn {
4485 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4486 Self::load_erased(&mut f)
4487 }
4488 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4489 Self {
4490 create_private_data_slot_ext: unsafe {
4491 unsafe extern "system" fn create_private_data_slot_ext(
4492 _device: crate::vk::Device,
4493 _p_create_info: *const PrivateDataSlotCreateInfo<'_>,
4494 _p_allocator: *const AllocationCallbacks<'_>,
4495 _p_private_data_slot: *mut PrivateDataSlot,
4496 ) -> Result {
4497 panic!(concat!(
4498 "Unable to load ",
4499 stringify!(create_private_data_slot_ext)
4500 ))
4501 }
4502 let cname =
4503 CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlotEXT\0");
4504 let val = _f(cname);
4505 if val.is_null() {
4506 create_private_data_slot_ext
4507 } else {
4508 ::core::mem::transmute(val)
4509 }
4510 },
4511 destroy_private_data_slot_ext: unsafe {
4512 unsafe extern "system" fn destroy_private_data_slot_ext(
4513 _device: crate::vk::Device,
4514 _private_data_slot: PrivateDataSlot,
4515 _p_allocator: *const AllocationCallbacks<'_>,
4516 ) {
4517 panic!(concat!(
4518 "Unable to load ",
4519 stringify!(destroy_private_data_slot_ext)
4520 ))
4521 }
4522 let cname =
4523 CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlotEXT\0");
4524 let val = _f(cname);
4525 if val.is_null() {
4526 destroy_private_data_slot_ext
4527 } else {
4528 ::core::mem::transmute(val)
4529 }
4530 },
4531 set_private_data_ext: unsafe {
4532 unsafe extern "system" fn set_private_data_ext(
4533 _device: crate::vk::Device,
4534 _object_type: ObjectType,
4535 _object_handle: u64,
4536 _private_data_slot: PrivateDataSlot,
4537 _data: u64,
4538 ) -> Result {
4539 panic!(concat!("Unable to load ", stringify!(set_private_data_ext)))
4540 }
4541 let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0");
4542 let val = _f(cname);
4543 if val.is_null() {
4544 set_private_data_ext
4545 } else {
4546 ::core::mem::transmute(val)
4547 }
4548 },
4549 get_private_data_ext: unsafe {
4550 unsafe extern "system" fn get_private_data_ext(
4551 _device: crate::vk::Device,
4552 _object_type: ObjectType,
4553 _object_handle: u64,
4554 _private_data_slot: PrivateDataSlot,
4555 _p_data: *mut u64,
4556 ) {
4557 panic!(concat!("Unable to load ", stringify!(get_private_data_ext)))
4558 }
4559 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0");
4560 let val = _f(cname);
4561 if val.is_null() {
4562 get_private_data_ext
4563 } else {
4564 ::core::mem::transmute(val)
4565 }
4566 },
4567 }
4568 }
4569 }
4570 }
4571 #[doc = "VK_EXT_pipeline_creation_cache_control"]
4572 pub mod pipeline_creation_cache_control {
4573 use super::super::*;
4574 pub use {
4575 crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_NAME as NAME,
4576 crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION as SPEC_VERSION,
4577 };
4578 }
4579 #[doc = "VK_EXT_metal_objects"]
4580 pub mod metal_objects {
4581 use super::super::*;
4582 pub use {
4583 crate::vk::EXT_METAL_OBJECTS_NAME as NAME,
4584 crate::vk::EXT_METAL_OBJECTS_SPEC_VERSION as SPEC_VERSION,
4585 };
4586 #[doc = "VK_EXT_metal_objects device-level functions"]
4587 #[derive(Clone)]
4588 pub struct Device {
4589 pub(crate) fp: DeviceFn,
4590 pub(crate) handle: crate::vk::Device,
4591 }
4592 impl Device {
4593 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4594 let handle = device.handle();
4595 let fp = DeviceFn::load(|name| unsafe {
4596 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4597 });
4598 Self { handle, fp }
4599 }
4600 #[inline]
4601 pub fn fp(&self) -> &DeviceFn {
4602 &self.fp
4603 }
4604 #[inline]
4605 pub fn device(&self) -> crate::vk::Device {
4606 self.handle
4607 }
4608 }
4609 #[derive(Clone)]
4610 #[doc = "Raw VK_EXT_metal_objects device-level function pointers"]
4611 pub struct DeviceFn {
4612 pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT,
4613 }
4614 unsafe impl Send for DeviceFn {}
4615 unsafe impl Sync for DeviceFn {}
4616 impl DeviceFn {
4617 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4618 Self::load_erased(&mut f)
4619 }
4620 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4621 Self {
4622 export_metal_objects_ext: unsafe {
4623 unsafe extern "system" fn export_metal_objects_ext(
4624 _device: crate::vk::Device,
4625 _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT<'_>,
4626 ) {
4627 panic!(concat!(
4628 "Unable to load ",
4629 stringify!(export_metal_objects_ext)
4630 ))
4631 }
4632 let cname =
4633 CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0");
4634 let val = _f(cname);
4635 if val.is_null() {
4636 export_metal_objects_ext
4637 } else {
4638 ::core::mem::transmute(val)
4639 }
4640 },
4641 }
4642 }
4643 }
4644 }
4645 #[doc = "VK_EXT_descriptor_buffer"]
4646 pub mod descriptor_buffer {
4647 use super::super::*;
4648 pub use {
4649 crate::vk::EXT_DESCRIPTOR_BUFFER_NAME as NAME,
4650 crate::vk::EXT_DESCRIPTOR_BUFFER_SPEC_VERSION as SPEC_VERSION,
4651 };
4652 #[doc = "VK_EXT_descriptor_buffer device-level functions"]
4653 #[derive(Clone)]
4654 pub struct Device {
4655 pub(crate) fp: DeviceFn,
4656 pub(crate) handle: crate::vk::Device,
4657 }
4658 impl Device {
4659 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4660 let handle = device.handle();
4661 let fp = DeviceFn::load(|name| unsafe {
4662 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4663 });
4664 Self { handle, fp }
4665 }
4666 #[inline]
4667 pub fn fp(&self) -> &DeviceFn {
4668 &self.fp
4669 }
4670 #[inline]
4671 pub fn device(&self) -> crate::vk::Device {
4672 self.handle
4673 }
4674 }
4675 #[derive(Clone)]
4676 #[doc = "Raw VK_EXT_descriptor_buffer device-level function pointers"]
4677 pub struct DeviceFn {
4678 pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT,
4679 pub get_descriptor_set_layout_binding_offset_ext:
4680 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
4681 pub get_descriptor_ext: PFN_vkGetDescriptorEXT,
4682 pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT,
4683 pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT,
4684 pub cmd_bind_descriptor_buffer_embedded_samplers_ext:
4685 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
4686 pub get_buffer_opaque_capture_descriptor_data_ext:
4687 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
4688 pub get_image_opaque_capture_descriptor_data_ext:
4689 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
4690 pub get_image_view_opaque_capture_descriptor_data_ext:
4691 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
4692 pub get_sampler_opaque_capture_descriptor_data_ext:
4693 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
4694 pub get_acceleration_structure_opaque_capture_descriptor_data_ext:
4695 PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
4696 }
4697 unsafe impl Send for DeviceFn {}
4698 unsafe impl Sync for DeviceFn {}
4699 impl DeviceFn {
4700 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4701 Self::load_erased(&mut f)
4702 }
4703 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4704 Self {
4705 get_descriptor_set_layout_size_ext: unsafe {
4706 unsafe extern "system" fn get_descriptor_set_layout_size_ext(
4707 _device: crate::vk::Device,
4708 _layout: DescriptorSetLayout,
4709 _p_layout_size_in_bytes: *mut DeviceSize,
4710 ) {
4711 panic!(concat!(
4712 "Unable to load ",
4713 stringify!(get_descriptor_set_layout_size_ext)
4714 ))
4715 }
4716 let cname = CStr::from_bytes_with_nul_unchecked(
4717 b"vkGetDescriptorSetLayoutSizeEXT\0",
4718 );
4719 let val = _f(cname);
4720 if val.is_null() {
4721 get_descriptor_set_layout_size_ext
4722 } else {
4723 ::core::mem::transmute(val)
4724 }
4725 },
4726 get_descriptor_set_layout_binding_offset_ext: unsafe {
4727 unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext(
4728 _device: crate::vk::Device,
4729 _layout: DescriptorSetLayout,
4730 _binding: u32,
4731 _p_offset: *mut DeviceSize,
4732 ) {
4733 panic!(concat!(
4734 "Unable to load ",
4735 stringify!(get_descriptor_set_layout_binding_offset_ext)
4736 ))
4737 }
4738 let cname = CStr::from_bytes_with_nul_unchecked(
4739 b"vkGetDescriptorSetLayoutBindingOffsetEXT\0",
4740 );
4741 let val = _f(cname);
4742 if val.is_null() {
4743 get_descriptor_set_layout_binding_offset_ext
4744 } else {
4745 ::core::mem::transmute(val)
4746 }
4747 },
4748 get_descriptor_ext: unsafe {
4749 unsafe extern "system" fn get_descriptor_ext(
4750 _device: crate::vk::Device,
4751 _p_descriptor_info: *const DescriptorGetInfoEXT<'_>,
4752 _data_size: usize,
4753 _p_descriptor: *mut c_void,
4754 ) {
4755 panic!(concat!("Unable to load ", stringify!(get_descriptor_ext)))
4756 }
4757 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0");
4758 let val = _f(cname);
4759 if val.is_null() {
4760 get_descriptor_ext
4761 } else {
4762 ::core::mem::transmute(val)
4763 }
4764 },
4765 cmd_bind_descriptor_buffers_ext: unsafe {
4766 unsafe extern "system" fn cmd_bind_descriptor_buffers_ext(
4767 _command_buffer: CommandBuffer,
4768 _buffer_count: u32,
4769 _p_binding_infos: *const DescriptorBufferBindingInfoEXT<'_>,
4770 ) {
4771 panic!(concat!(
4772 "Unable to load ",
4773 stringify!(cmd_bind_descriptor_buffers_ext)
4774 ))
4775 }
4776 let cname =
4777 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorBuffersEXT\0");
4778 let val = _f(cname);
4779 if val.is_null() {
4780 cmd_bind_descriptor_buffers_ext
4781 } else {
4782 ::core::mem::transmute(val)
4783 }
4784 },
4785 cmd_set_descriptor_buffer_offsets_ext: unsafe {
4786 unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext(
4787 _command_buffer: CommandBuffer,
4788 _pipeline_bind_point: PipelineBindPoint,
4789 _layout: PipelineLayout,
4790 _first_set: u32,
4791 _set_count: u32,
4792 _p_buffer_indices: *const u32,
4793 _p_offsets: *const DeviceSize,
4794 ) {
4795 panic!(concat!(
4796 "Unable to load ",
4797 stringify!(cmd_set_descriptor_buffer_offsets_ext)
4798 ))
4799 }
4800 let cname = CStr::from_bytes_with_nul_unchecked(
4801 b"vkCmdSetDescriptorBufferOffsetsEXT\0",
4802 );
4803 let val = _f(cname);
4804 if val.is_null() {
4805 cmd_set_descriptor_buffer_offsets_ext
4806 } else {
4807 ::core::mem::transmute(val)
4808 }
4809 },
4810 cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe {
4811 unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
4812 _command_buffer: CommandBuffer,
4813 _pipeline_bind_point: PipelineBindPoint,
4814 _layout: PipelineLayout,
4815 _set: u32,
4816 ) {
4817 panic!(concat!(
4818 "Unable to load ",
4819 stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext)
4820 ))
4821 }
4822 let cname = CStr::from_bytes_with_nul_unchecked(
4823 b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0",
4824 );
4825 let val = _f(cname);
4826 if val.is_null() {
4827 cmd_bind_descriptor_buffer_embedded_samplers_ext
4828 } else {
4829 ::core::mem::transmute(val)
4830 }
4831 },
4832 get_buffer_opaque_capture_descriptor_data_ext: unsafe {
4833 unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext(
4834 _device: crate::vk::Device,
4835 _p_info: *const BufferCaptureDescriptorDataInfoEXT<'_>,
4836 _p_data: *mut c_void,
4837 ) -> Result {
4838 panic!(concat!(
4839 "Unable to load ",
4840 stringify!(get_buffer_opaque_capture_descriptor_data_ext)
4841 ))
4842 }
4843 let cname = CStr::from_bytes_with_nul_unchecked(
4844 b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0",
4845 );
4846 let val = _f(cname);
4847 if val.is_null() {
4848 get_buffer_opaque_capture_descriptor_data_ext
4849 } else {
4850 ::core::mem::transmute(val)
4851 }
4852 },
4853 get_image_opaque_capture_descriptor_data_ext: unsafe {
4854 unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext(
4855 _device: crate::vk::Device,
4856 _p_info: *const ImageCaptureDescriptorDataInfoEXT<'_>,
4857 _p_data: *mut c_void,
4858 ) -> Result {
4859 panic!(concat!(
4860 "Unable to load ",
4861 stringify!(get_image_opaque_capture_descriptor_data_ext)
4862 ))
4863 }
4864 let cname = CStr::from_bytes_with_nul_unchecked(
4865 b"vkGetImageOpaqueCaptureDescriptorDataEXT\0",
4866 );
4867 let val = _f(cname);
4868 if val.is_null() {
4869 get_image_opaque_capture_descriptor_data_ext
4870 } else {
4871 ::core::mem::transmute(val)
4872 }
4873 },
4874 get_image_view_opaque_capture_descriptor_data_ext: unsafe {
4875 unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext(
4876 _device: crate::vk::Device,
4877 _p_info: *const ImageViewCaptureDescriptorDataInfoEXT<'_>,
4878 _p_data: *mut c_void,
4879 ) -> Result {
4880 panic!(concat!(
4881 "Unable to load ",
4882 stringify!(get_image_view_opaque_capture_descriptor_data_ext)
4883 ))
4884 }
4885 let cname = CStr::from_bytes_with_nul_unchecked(
4886 b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0",
4887 );
4888 let val = _f(cname);
4889 if val.is_null() {
4890 get_image_view_opaque_capture_descriptor_data_ext
4891 } else {
4892 ::core::mem::transmute(val)
4893 }
4894 },
4895 get_sampler_opaque_capture_descriptor_data_ext: unsafe {
4896 unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext(
4897 _device: crate::vk::Device,
4898 _p_info: *const SamplerCaptureDescriptorDataInfoEXT<'_>,
4899 _p_data: *mut c_void,
4900 ) -> Result {
4901 panic!(concat!(
4902 "Unable to load ",
4903 stringify!(get_sampler_opaque_capture_descriptor_data_ext)
4904 ))
4905 }
4906 let cname = CStr::from_bytes_with_nul_unchecked(
4907 b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0",
4908 );
4909 let val = _f(cname);
4910 if val.is_null() {
4911 get_sampler_opaque_capture_descriptor_data_ext
4912 } else {
4913 ::core::mem::transmute(val)
4914 }
4915 },
4916 get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe {
4917 unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
4918 _device: crate::vk::Device,
4919 _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
4920 _p_data: *mut c_void,
4921 ) -> Result {
4922 panic!(concat!(
4923 "Unable to load ",
4924 stringify!(
4925 get_acceleration_structure_opaque_capture_descriptor_data_ext
4926 )
4927 ))
4928 }
4929 let cname = CStr::from_bytes_with_nul_unchecked(
4930 b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0",
4931 );
4932 let val = _f(cname);
4933 if val.is_null() {
4934 get_acceleration_structure_opaque_capture_descriptor_data_ext
4935 } else {
4936 ::core::mem::transmute(val)
4937 }
4938 },
4939 }
4940 }
4941 }
4942 }
4943 #[doc = "VK_EXT_graphics_pipeline_library"]
4944 pub mod graphics_pipeline_library {
4945 use super::super::*;
4946 pub use {
4947 crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_NAME as NAME,
4948 crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION as SPEC_VERSION,
4949 };
4950 }
4951 #[doc = "VK_EXT_mesh_shader"]
4952 pub mod mesh_shader {
4953 use super::super::*;
4954 pub use {
4955 crate::vk::EXT_MESH_SHADER_NAME as NAME,
4956 crate::vk::EXT_MESH_SHADER_SPEC_VERSION as SPEC_VERSION,
4957 };
4958 #[doc = "VK_EXT_mesh_shader device-level functions"]
4959 #[derive(Clone)]
4960 pub struct Device {
4961 pub(crate) fp: DeviceFn,
4962 pub(crate) handle: crate::vk::Device,
4963 }
4964 impl Device {
4965 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
4966 let handle = device.handle();
4967 let fp = DeviceFn::load(|name| unsafe {
4968 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
4969 });
4970 Self { handle, fp }
4971 }
4972 #[inline]
4973 pub fn fp(&self) -> &DeviceFn {
4974 &self.fp
4975 }
4976 #[inline]
4977 pub fn device(&self) -> crate::vk::Device {
4978 self.handle
4979 }
4980 }
4981 #[derive(Clone)]
4982 #[doc = "Raw VK_EXT_mesh_shader device-level function pointers"]
4983 pub struct DeviceFn {
4984 pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT,
4985 pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT,
4986 pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT,
4987 }
4988 unsafe impl Send for DeviceFn {}
4989 unsafe impl Sync for DeviceFn {}
4990 impl DeviceFn {
4991 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
4992 Self::load_erased(&mut f)
4993 }
4994 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
4995 Self {
4996 cmd_draw_mesh_tasks_ext: unsafe {
4997 unsafe extern "system" fn cmd_draw_mesh_tasks_ext(
4998 _command_buffer: CommandBuffer,
4999 _group_count_x: u32,
5000 _group_count_y: u32,
5001 _group_count_z: u32,
5002 ) {
5003 panic!(concat!(
5004 "Unable to load ",
5005 stringify!(cmd_draw_mesh_tasks_ext)
5006 ))
5007 }
5008 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0");
5009 let val = _f(cname);
5010 if val.is_null() {
5011 cmd_draw_mesh_tasks_ext
5012 } else {
5013 ::core::mem::transmute(val)
5014 }
5015 },
5016 cmd_draw_mesh_tasks_indirect_ext: unsafe {
5017 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext(
5018 _command_buffer: CommandBuffer,
5019 _buffer: Buffer,
5020 _offset: DeviceSize,
5021 _draw_count: u32,
5022 _stride: u32,
5023 ) {
5024 panic!(concat!(
5025 "Unable to load ",
5026 stringify!(cmd_draw_mesh_tasks_indirect_ext)
5027 ))
5028 }
5029 let cname =
5030 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksIndirectEXT\0");
5031 let val = _f(cname);
5032 if val.is_null() {
5033 cmd_draw_mesh_tasks_indirect_ext
5034 } else {
5035 ::core::mem::transmute(val)
5036 }
5037 },
5038 cmd_draw_mesh_tasks_indirect_count_ext: unsafe {
5039 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext(
5040 _command_buffer: CommandBuffer,
5041 _buffer: Buffer,
5042 _offset: DeviceSize,
5043 _count_buffer: Buffer,
5044 _count_buffer_offset: DeviceSize,
5045 _max_draw_count: u32,
5046 _stride: u32,
5047 ) {
5048 panic!(concat!(
5049 "Unable to load ",
5050 stringify!(cmd_draw_mesh_tasks_indirect_count_ext)
5051 ))
5052 }
5053 let cname = CStr::from_bytes_with_nul_unchecked(
5054 b"vkCmdDrawMeshTasksIndirectCountEXT\0",
5055 );
5056 let val = _f(cname);
5057 if val.is_null() {
5058 cmd_draw_mesh_tasks_indirect_count_ext
5059 } else {
5060 ::core::mem::transmute(val)
5061 }
5062 },
5063 }
5064 }
5065 }
5066 }
5067 #[doc = "VK_EXT_ycbcr_2plane_444_formats"]
5068 pub mod ycbcr_2plane_444_formats {
5069 use super::super::*;
5070 pub use {
5071 crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_NAME as NAME,
5072 crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION as SPEC_VERSION,
5073 };
5074 }
5075 #[doc = "VK_EXT_fragment_density_map2"]
5076 pub mod fragment_density_map2 {
5077 use super::super::*;
5078 pub use {
5079 crate::vk::EXT_FRAGMENT_DENSITY_MAP2_NAME as NAME,
5080 crate::vk::EXT_FRAGMENT_DENSITY_MAP2_SPEC_VERSION as SPEC_VERSION,
5081 };
5082 }
5083 #[doc = "VK_EXT_image_robustness"]
5084 pub mod image_robustness {
5085 use super::super::*;
5086 pub use {
5087 crate::vk::EXT_IMAGE_ROBUSTNESS_NAME as NAME,
5088 crate::vk::EXT_IMAGE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION,
5089 };
5090 }
5091 #[doc = "VK_EXT_image_compression_control"]
5092 pub mod image_compression_control {
5093 use super::super::*;
5094 pub use {
5095 crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_NAME as NAME,
5096 crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION as SPEC_VERSION,
5097 };
5098 #[doc = "VK_EXT_image_compression_control device-level functions"]
5099 #[derive(Clone)]
5100 pub struct Device {
5101 pub(crate) fp: DeviceFn,
5102 pub(crate) handle: crate::vk::Device,
5103 }
5104 impl Device {
5105 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5106 let handle = device.handle();
5107 let fp = DeviceFn::load(|name| unsafe {
5108 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5109 });
5110 Self { handle, fp }
5111 }
5112 #[inline]
5113 pub fn fp(&self) -> &DeviceFn {
5114 &self.fp
5115 }
5116 #[inline]
5117 pub fn device(&self) -> crate::vk::Device {
5118 self.handle
5119 }
5120 }
5121 #[derive(Clone)]
5122 #[doc = "Raw VK_EXT_image_compression_control device-level function pointers"]
5123 pub struct DeviceFn {
5124 pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR,
5125 }
5126 unsafe impl Send for DeviceFn {}
5127 unsafe impl Sync for DeviceFn {}
5128 impl DeviceFn {
5129 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5130 Self::load_erased(&mut f)
5131 }
5132 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5133 Self {
5134 get_image_subresource_layout2_ext: unsafe {
5135 unsafe extern "system" fn get_image_subresource_layout2_ext(
5136 _device: crate::vk::Device,
5137 _image: Image,
5138 _p_subresource: *const ImageSubresource2KHR<'_>,
5139 _p_layout: *mut SubresourceLayout2KHR<'_>,
5140 ) {
5141 panic!(concat!(
5142 "Unable to load ",
5143 stringify!(get_image_subresource_layout2_ext)
5144 ))
5145 }
5146 let cname = CStr::from_bytes_with_nul_unchecked(
5147 b"vkGetImageSubresourceLayout2EXT\0",
5148 );
5149 let val = _f(cname);
5150 if val.is_null() {
5151 get_image_subresource_layout2_ext
5152 } else {
5153 ::core::mem::transmute(val)
5154 }
5155 },
5156 }
5157 }
5158 }
5159 }
5160 #[doc = "VK_EXT_attachment_feedback_loop_layout"]
5161 pub mod attachment_feedback_loop_layout {
5162 use super::super::*;
5163 pub use {
5164 crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_NAME as NAME,
5165 crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION as SPEC_VERSION,
5166 };
5167 }
5168 #[doc = "VK_EXT_4444_formats"]
5169 pub mod _4444_formats {
5170 use super::super::*;
5171 pub use {
5172 crate::vk::EXT_4444_FORMATS_NAME as NAME,
5173 crate::vk::EXT_4444_FORMATS_SPEC_VERSION as SPEC_VERSION,
5174 };
5175 }
5176 #[doc = "VK_EXT_device_fault"]
5177 pub mod device_fault {
5178 use super::super::*;
5179 pub use {
5180 crate::vk::EXT_DEVICE_FAULT_NAME as NAME,
5181 crate::vk::EXT_DEVICE_FAULT_SPEC_VERSION as SPEC_VERSION,
5182 };
5183 #[doc = "VK_EXT_device_fault device-level functions"]
5184 #[derive(Clone)]
5185 pub struct Device {
5186 pub(crate) fp: DeviceFn,
5187 pub(crate) handle: crate::vk::Device,
5188 }
5189 impl Device {
5190 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5191 let handle = device.handle();
5192 let fp = DeviceFn::load(|name| unsafe {
5193 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5194 });
5195 Self { handle, fp }
5196 }
5197 #[inline]
5198 pub fn fp(&self) -> &DeviceFn {
5199 &self.fp
5200 }
5201 #[inline]
5202 pub fn device(&self) -> crate::vk::Device {
5203 self.handle
5204 }
5205 }
5206 #[derive(Clone)]
5207 #[doc = "Raw VK_EXT_device_fault device-level function pointers"]
5208 pub struct DeviceFn {
5209 pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT,
5210 }
5211 unsafe impl Send for DeviceFn {}
5212 unsafe impl Sync for DeviceFn {}
5213 impl DeviceFn {
5214 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5215 Self::load_erased(&mut f)
5216 }
5217 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5218 Self {
5219 get_device_fault_info_ext: unsafe {
5220 unsafe extern "system" fn get_device_fault_info_ext(
5221 _device: crate::vk::Device,
5222 _p_fault_counts: *mut DeviceFaultCountsEXT<'_>,
5223 _p_fault_info: *mut DeviceFaultInfoEXT<'_>,
5224 ) -> Result {
5225 panic!(concat!(
5226 "Unable to load ",
5227 stringify!(get_device_fault_info_ext)
5228 ))
5229 }
5230 let cname =
5231 CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0");
5232 let val = _f(cname);
5233 if val.is_null() {
5234 get_device_fault_info_ext
5235 } else {
5236 ::core::mem::transmute(val)
5237 }
5238 },
5239 }
5240 }
5241 }
5242 }
5243 #[doc = "VK_EXT_rgba10x6_formats"]
5244 pub mod rgba10x6_formats {
5245 use super::super::*;
5246 pub use {
5247 crate::vk::EXT_RGBA10X6_FORMATS_NAME as NAME,
5248 crate::vk::EXT_RGBA10X6_FORMATS_SPEC_VERSION as SPEC_VERSION,
5249 };
5250 }
5251 #[doc = "VK_EXT_directfb_surface"]
5252 pub mod directfb_surface {
5253 use super::super::*;
5254 pub use {
5255 crate::vk::EXT_DIRECTFB_SURFACE_NAME as NAME,
5256 crate::vk::EXT_DIRECTFB_SURFACE_SPEC_VERSION as SPEC_VERSION,
5257 };
5258 #[doc = "VK_EXT_directfb_surface instance-level functions"]
5259 #[derive(Clone)]
5260 pub struct Instance {
5261 pub(crate) fp: InstanceFn,
5262 pub(crate) handle: crate::vk::Instance,
5263 }
5264 impl Instance {
5265 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
5266 let handle = instance.handle();
5267 let fp = InstanceFn::load(|name| unsafe {
5268 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
5269 });
5270 Self { handle, fp }
5271 }
5272 #[inline]
5273 pub fn fp(&self) -> &InstanceFn {
5274 &self.fp
5275 }
5276 #[inline]
5277 pub fn instance(&self) -> crate::vk::Instance {
5278 self.handle
5279 }
5280 }
5281 #[derive(Clone)]
5282 #[doc = "Raw VK_EXT_directfb_surface instance-level function pointers"]
5283 pub struct InstanceFn {
5284 pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT,
5285 pub get_physical_device_direct_fb_presentation_support_ext:
5286 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
5287 }
5288 unsafe impl Send for InstanceFn {}
5289 unsafe impl Sync for InstanceFn {}
5290 impl InstanceFn {
5291 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5292 Self::load_erased(&mut f)
5293 }
5294 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5295 Self {
5296 create_direct_fb_surface_ext: unsafe {
5297 unsafe extern "system" fn create_direct_fb_surface_ext(
5298 _instance: crate::vk::Instance,
5299 _p_create_info: *const DirectFBSurfaceCreateInfoEXT<'_>,
5300 _p_allocator: *const AllocationCallbacks<'_>,
5301 _p_surface: *mut SurfaceKHR,
5302 ) -> Result {
5303 panic!(concat!(
5304 "Unable to load ",
5305 stringify!(create_direct_fb_surface_ext)
5306 ))
5307 }
5308 let cname =
5309 CStr::from_bytes_with_nul_unchecked(b"vkCreateDirectFBSurfaceEXT\0");
5310 let val = _f(cname);
5311 if val.is_null() {
5312 create_direct_fb_surface_ext
5313 } else {
5314 ::core::mem::transmute(val)
5315 }
5316 },
5317 get_physical_device_direct_fb_presentation_support_ext: unsafe {
5318 unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext(
5319 _physical_device: PhysicalDevice,
5320 _queue_family_index: u32,
5321 _dfb: *mut IDirectFB,
5322 ) -> Bool32 {
5323 panic!(concat!(
5324 "Unable to load ",
5325 stringify!(get_physical_device_direct_fb_presentation_support_ext)
5326 ))
5327 }
5328 let cname = CStr::from_bytes_with_nul_unchecked(
5329 b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0",
5330 );
5331 let val = _f(cname);
5332 if val.is_null() {
5333 get_physical_device_direct_fb_presentation_support_ext
5334 } else {
5335 ::core::mem::transmute(val)
5336 }
5337 },
5338 }
5339 }
5340 }
5341 }
5342 #[doc = "VK_EXT_vertex_input_dynamic_state"]
5343 pub mod vertex_input_dynamic_state {
5344 use super::super::*;
5345 pub use {
5346 crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_NAME as NAME,
5347 crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
5348 };
5349 #[doc = "VK_EXT_vertex_input_dynamic_state device-level functions"]
5350 #[derive(Clone)]
5351 pub struct Device {
5352 pub(crate) fp: DeviceFn,
5353 pub(crate) handle: crate::vk::Device,
5354 }
5355 impl Device {
5356 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5357 let handle = device.handle();
5358 let fp = DeviceFn::load(|name| unsafe {
5359 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5360 });
5361 Self { handle, fp }
5362 }
5363 #[inline]
5364 pub fn fp(&self) -> &DeviceFn {
5365 &self.fp
5366 }
5367 #[inline]
5368 pub fn device(&self) -> crate::vk::Device {
5369 self.handle
5370 }
5371 }
5372 #[derive(Clone)]
5373 #[doc = "Raw VK_EXT_vertex_input_dynamic_state device-level function pointers"]
5374 pub struct DeviceFn {
5375 pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
5376 }
5377 unsafe impl Send for DeviceFn {}
5378 unsafe impl Sync for DeviceFn {}
5379 impl DeviceFn {
5380 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5381 Self::load_erased(&mut f)
5382 }
5383 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5384 Self {
5385 cmd_set_vertex_input_ext: unsafe {
5386 unsafe extern "system" fn cmd_set_vertex_input_ext(
5387 _command_buffer: CommandBuffer,
5388 _vertex_binding_description_count: u32,
5389 _p_vertex_binding_descriptions : * const VertexInputBindingDescription2EXT < '_ >,
5390 _vertex_attribute_description_count: u32,
5391 _p_vertex_attribute_descriptions : * const VertexInputAttributeDescription2EXT < '_ >,
5392 ) {
5393 panic!(concat!(
5394 "Unable to load ",
5395 stringify!(cmd_set_vertex_input_ext)
5396 ))
5397 }
5398 let cname =
5399 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
5400 let val = _f(cname);
5401 if val.is_null() {
5402 cmd_set_vertex_input_ext
5403 } else {
5404 ::core::mem::transmute(val)
5405 }
5406 },
5407 }
5408 }
5409 }
5410 }
5411 #[doc = "VK_EXT_physical_device_drm"]
5412 pub mod physical_device_drm {
5413 use super::super::*;
5414 pub use {
5415 crate::vk::EXT_PHYSICAL_DEVICE_DRM_NAME as NAME,
5416 crate::vk::EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION as SPEC_VERSION,
5417 };
5418 }
5419 #[doc = "VK_EXT_device_address_binding_report"]
5420 pub mod device_address_binding_report {
5421 use super::super::*;
5422 pub use {
5423 crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_NAME as NAME,
5424 crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION as SPEC_VERSION,
5425 };
5426 }
5427 #[doc = "VK_EXT_depth_clip_control"]
5428 pub mod depth_clip_control {
5429 use super::super::*;
5430 pub use {
5431 crate::vk::EXT_DEPTH_CLIP_CONTROL_NAME as NAME,
5432 crate::vk::EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION as SPEC_VERSION,
5433 };
5434 }
5435 #[doc = "VK_EXT_primitive_topology_list_restart"]
5436 pub mod primitive_topology_list_restart {
5437 use super::super::*;
5438 pub use {
5439 crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_NAME as NAME,
5440 crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION as SPEC_VERSION,
5441 };
5442 }
5443 #[doc = "VK_EXT_pipeline_properties"]
5444 pub mod pipeline_properties {
5445 use super::super::*;
5446 pub use {
5447 crate::vk::EXT_PIPELINE_PROPERTIES_NAME as NAME,
5448 crate::vk::EXT_PIPELINE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
5449 };
5450 #[doc = "VK_EXT_pipeline_properties device-level functions"]
5451 #[derive(Clone)]
5452 pub struct Device {
5453 pub(crate) fp: DeviceFn,
5454 pub(crate) handle: crate::vk::Device,
5455 }
5456 impl Device {
5457 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5458 let handle = device.handle();
5459 let fp = DeviceFn::load(|name| unsafe {
5460 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5461 });
5462 Self { handle, fp }
5463 }
5464 #[inline]
5465 pub fn fp(&self) -> &DeviceFn {
5466 &self.fp
5467 }
5468 #[inline]
5469 pub fn device(&self) -> crate::vk::Device {
5470 self.handle
5471 }
5472 }
5473 #[allow(non_camel_case_types)]
5474 #[doc = "Implemented for all types that can be passed as argument to `pipeline_properties` in [`PFN_vkGetPipelinePropertiesEXT`]"]
5475 pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {}
5476 unsafe impl GetPipelinePropertiesEXTParamPipelineProperties
5477 for PipelinePropertiesIdentifierEXT<'_>
5478 {
5479 }
5480 #[derive(Clone)]
5481 #[doc = "Raw VK_EXT_pipeline_properties device-level function pointers"]
5482 pub struct DeviceFn {
5483 pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT,
5484 }
5485 unsafe impl Send for DeviceFn {}
5486 unsafe impl Sync for DeviceFn {}
5487 impl DeviceFn {
5488 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5489 Self::load_erased(&mut f)
5490 }
5491 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5492 Self {
5493 get_pipeline_properties_ext: unsafe {
5494 unsafe extern "system" fn get_pipeline_properties_ext(
5495 _device: crate::vk::Device,
5496 _p_pipeline_info: *const PipelineInfoEXT<'_>,
5497 _p_pipeline_properties: *mut BaseOutStructure<'_>,
5498 ) -> Result {
5499 panic!(concat!(
5500 "Unable to load ",
5501 stringify!(get_pipeline_properties_ext)
5502 ))
5503 }
5504 let cname =
5505 CStr::from_bytes_with_nul_unchecked(b"vkGetPipelinePropertiesEXT\0");
5506 let val = _f(cname);
5507 if val.is_null() {
5508 get_pipeline_properties_ext
5509 } else {
5510 ::core::mem::transmute(val)
5511 }
5512 },
5513 }
5514 }
5515 }
5516 }
5517 #[doc = "VK_EXT_frame_boundary"]
5518 pub mod frame_boundary {
5519 use super::super::*;
5520 pub use {
5521 crate::vk::EXT_FRAME_BOUNDARY_NAME as NAME,
5522 crate::vk::EXT_FRAME_BOUNDARY_SPEC_VERSION as SPEC_VERSION,
5523 };
5524 }
5525 #[doc = "VK_EXT_multisampled_render_to_single_sampled"]
5526 pub mod multisampled_render_to_single_sampled {
5527 use super::super::*;
5528 pub use {
5529 crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_NAME as NAME,
5530 crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION as SPEC_VERSION,
5531 };
5532 }
5533 #[doc = "VK_EXT_extended_dynamic_state2"]
5534 pub mod extended_dynamic_state2 {
5535 use super::super::*;
5536 pub use {
5537 crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_NAME as NAME,
5538 crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_SPEC_VERSION as SPEC_VERSION,
5539 };
5540 #[doc = "VK_EXT_extended_dynamic_state2 device-level functions"]
5541 #[derive(Clone)]
5542 pub struct Device {
5543 pub(crate) fp: DeviceFn,
5544 pub(crate) handle: crate::vk::Device,
5545 }
5546 impl Device {
5547 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5548 let handle = device.handle();
5549 let fp = DeviceFn::load(|name| unsafe {
5550 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5551 });
5552 Self { handle, fp }
5553 }
5554 #[inline]
5555 pub fn fp(&self) -> &DeviceFn {
5556 &self.fp
5557 }
5558 #[inline]
5559 pub fn device(&self) -> crate::vk::Device {
5560 self.handle
5561 }
5562 }
5563 #[derive(Clone)]
5564 #[doc = "Raw VK_EXT_extended_dynamic_state2 device-level function pointers"]
5565 pub struct DeviceFn {
5566 pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT,
5567 pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable,
5568 pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable,
5569 pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT,
5570 pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable,
5571 }
5572 unsafe impl Send for DeviceFn {}
5573 unsafe impl Sync for DeviceFn {}
5574 impl DeviceFn {
5575 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5576 Self::load_erased(&mut f)
5577 }
5578 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5579 Self {
5580 cmd_set_patch_control_points_ext: unsafe {
5581 unsafe extern "system" fn cmd_set_patch_control_points_ext(
5582 _command_buffer: CommandBuffer,
5583 _patch_control_points: u32,
5584 ) {
5585 panic!(concat!(
5586 "Unable to load ",
5587 stringify!(cmd_set_patch_control_points_ext)
5588 ))
5589 }
5590 let cname =
5591 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0");
5592 let val = _f(cname);
5593 if val.is_null() {
5594 cmd_set_patch_control_points_ext
5595 } else {
5596 ::core::mem::transmute(val)
5597 }
5598 },
5599 cmd_set_rasterizer_discard_enable_ext: unsafe {
5600 unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
5601 _command_buffer: CommandBuffer,
5602 _rasterizer_discard_enable: Bool32,
5603 ) {
5604 panic!(concat!(
5605 "Unable to load ",
5606 stringify!(cmd_set_rasterizer_discard_enable_ext)
5607 ))
5608 }
5609 let cname = CStr::from_bytes_with_nul_unchecked(
5610 b"vkCmdSetRasterizerDiscardEnableEXT\0",
5611 );
5612 let val = _f(cname);
5613 if val.is_null() {
5614 cmd_set_rasterizer_discard_enable_ext
5615 } else {
5616 ::core::mem::transmute(val)
5617 }
5618 },
5619 cmd_set_depth_bias_enable_ext: unsafe {
5620 unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
5621 _command_buffer: CommandBuffer,
5622 _depth_bias_enable: Bool32,
5623 ) {
5624 panic!(concat!(
5625 "Unable to load ",
5626 stringify!(cmd_set_depth_bias_enable_ext)
5627 ))
5628 }
5629 let cname =
5630 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0");
5631 let val = _f(cname);
5632 if val.is_null() {
5633 cmd_set_depth_bias_enable_ext
5634 } else {
5635 ::core::mem::transmute(val)
5636 }
5637 },
5638 cmd_set_logic_op_ext: unsafe {
5639 unsafe extern "system" fn cmd_set_logic_op_ext(
5640 _command_buffer: CommandBuffer,
5641 _logic_op: LogicOp,
5642 ) {
5643 panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
5644 }
5645 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
5646 let val = _f(cname);
5647 if val.is_null() {
5648 cmd_set_logic_op_ext
5649 } else {
5650 ::core::mem::transmute(val)
5651 }
5652 },
5653 cmd_set_primitive_restart_enable_ext: unsafe {
5654 unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
5655 _command_buffer: CommandBuffer,
5656 _primitive_restart_enable: Bool32,
5657 ) {
5658 panic!(concat!(
5659 "Unable to load ",
5660 stringify!(cmd_set_primitive_restart_enable_ext)
5661 ))
5662 }
5663 let cname = CStr::from_bytes_with_nul_unchecked(
5664 b"vkCmdSetPrimitiveRestartEnableEXT\0",
5665 );
5666 let val = _f(cname);
5667 if val.is_null() {
5668 cmd_set_primitive_restart_enable_ext
5669 } else {
5670 ::core::mem::transmute(val)
5671 }
5672 },
5673 }
5674 }
5675 }
5676 }
5677 #[doc = "VK_EXT_color_write_enable"]
5678 pub mod color_write_enable {
5679 use super::super::*;
5680 pub use {
5681 crate::vk::EXT_COLOR_WRITE_ENABLE_NAME as NAME,
5682 crate::vk::EXT_COLOR_WRITE_ENABLE_SPEC_VERSION as SPEC_VERSION,
5683 };
5684 #[doc = "VK_EXT_color_write_enable device-level functions"]
5685 #[derive(Clone)]
5686 pub struct Device {
5687 pub(crate) fp: DeviceFn,
5688 pub(crate) handle: crate::vk::Device,
5689 }
5690 impl Device {
5691 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5692 let handle = device.handle();
5693 let fp = DeviceFn::load(|name| unsafe {
5694 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5695 });
5696 Self { handle, fp }
5697 }
5698 #[inline]
5699 pub fn fp(&self) -> &DeviceFn {
5700 &self.fp
5701 }
5702 #[inline]
5703 pub fn device(&self) -> crate::vk::Device {
5704 self.handle
5705 }
5706 }
5707 #[derive(Clone)]
5708 #[doc = "Raw VK_EXT_color_write_enable device-level function pointers"]
5709 pub struct DeviceFn {
5710 pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT,
5711 }
5712 unsafe impl Send for DeviceFn {}
5713 unsafe impl Sync for DeviceFn {}
5714 impl DeviceFn {
5715 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5716 Self::load_erased(&mut f)
5717 }
5718 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5719 Self {
5720 cmd_set_color_write_enable_ext: unsafe {
5721 unsafe extern "system" fn cmd_set_color_write_enable_ext(
5722 _command_buffer: CommandBuffer,
5723 _attachment_count: u32,
5724 _p_color_write_enables: *const Bool32,
5725 ) {
5726 panic!(concat!(
5727 "Unable to load ",
5728 stringify!(cmd_set_color_write_enable_ext)
5729 ))
5730 }
5731 let cname =
5732 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteEnableEXT\0");
5733 let val = _f(cname);
5734 if val.is_null() {
5735 cmd_set_color_write_enable_ext
5736 } else {
5737 ::core::mem::transmute(val)
5738 }
5739 },
5740 }
5741 }
5742 }
5743 }
5744 #[doc = "VK_EXT_primitives_generated_query"]
5745 pub mod primitives_generated_query {
5746 use super::super::*;
5747 pub use {
5748 crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_NAME as NAME,
5749 crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION as SPEC_VERSION,
5750 };
5751 }
5752 #[doc = "VK_EXT_global_priority_query"]
5753 pub mod global_priority_query {
5754 use super::super::*;
5755 pub use {
5756 crate::vk::EXT_GLOBAL_PRIORITY_QUERY_NAME as NAME,
5757 crate::vk::EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION as SPEC_VERSION,
5758 };
5759 }
5760 #[doc = "VK_EXT_image_view_min_lod"]
5761 pub mod image_view_min_lod {
5762 use super::super::*;
5763 pub use {
5764 crate::vk::EXT_IMAGE_VIEW_MIN_LOD_NAME as NAME,
5765 crate::vk::EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION as SPEC_VERSION,
5766 };
5767 }
5768 #[doc = "VK_EXT_multi_draw"]
5769 pub mod multi_draw {
5770 use super::super::*;
5771 pub use {
5772 crate::vk::EXT_MULTI_DRAW_NAME as NAME,
5773 crate::vk::EXT_MULTI_DRAW_SPEC_VERSION as SPEC_VERSION,
5774 };
5775 #[doc = "VK_EXT_multi_draw device-level functions"]
5776 #[derive(Clone)]
5777 pub struct Device {
5778 pub(crate) fp: DeviceFn,
5779 pub(crate) handle: crate::vk::Device,
5780 }
5781 impl Device {
5782 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5783 let handle = device.handle();
5784 let fp = DeviceFn::load(|name| unsafe {
5785 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5786 });
5787 Self { handle, fp }
5788 }
5789 #[inline]
5790 pub fn fp(&self) -> &DeviceFn {
5791 &self.fp
5792 }
5793 #[inline]
5794 pub fn device(&self) -> crate::vk::Device {
5795 self.handle
5796 }
5797 }
5798 #[derive(Clone)]
5799 #[doc = "Raw VK_EXT_multi_draw device-level function pointers"]
5800 pub struct DeviceFn {
5801 pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT,
5802 pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT,
5803 }
5804 unsafe impl Send for DeviceFn {}
5805 unsafe impl Sync for DeviceFn {}
5806 impl DeviceFn {
5807 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5808 Self::load_erased(&mut f)
5809 }
5810 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5811 Self {
5812 cmd_draw_multi_ext: unsafe {
5813 unsafe extern "system" fn cmd_draw_multi_ext(
5814 _command_buffer: CommandBuffer,
5815 _draw_count: u32,
5816 _p_vertex_info: *const MultiDrawInfoEXT,
5817 _instance_count: u32,
5818 _first_instance: u32,
5819 _stride: u32,
5820 ) {
5821 panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext)))
5822 }
5823 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0");
5824 let val = _f(cname);
5825 if val.is_null() {
5826 cmd_draw_multi_ext
5827 } else {
5828 ::core::mem::transmute(val)
5829 }
5830 },
5831 cmd_draw_multi_indexed_ext: unsafe {
5832 unsafe extern "system" fn cmd_draw_multi_indexed_ext(
5833 _command_buffer: CommandBuffer,
5834 _draw_count: u32,
5835 _p_index_info: *const MultiDrawIndexedInfoEXT,
5836 _instance_count: u32,
5837 _first_instance: u32,
5838 _stride: u32,
5839 _p_vertex_offset: *const i32,
5840 ) {
5841 panic!(concat!(
5842 "Unable to load ",
5843 stringify!(cmd_draw_multi_indexed_ext)
5844 ))
5845 }
5846 let cname =
5847 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0");
5848 let val = _f(cname);
5849 if val.is_null() {
5850 cmd_draw_multi_indexed_ext
5851 } else {
5852 ::core::mem::transmute(val)
5853 }
5854 },
5855 }
5856 }
5857 }
5858 }
5859 #[doc = "VK_EXT_image_2d_view_of_3d"]
5860 pub mod image_2d_view_of_3d {
5861 use super::super::*;
5862 pub use {
5863 crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_NAME as NAME,
5864 crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION,
5865 };
5866 }
5867 #[doc = "VK_EXT_shader_tile_image"]
5868 pub mod shader_tile_image {
5869 use super::super::*;
5870 pub use {
5871 crate::vk::EXT_SHADER_TILE_IMAGE_NAME as NAME,
5872 crate::vk::EXT_SHADER_TILE_IMAGE_SPEC_VERSION as SPEC_VERSION,
5873 };
5874 }
5875 #[doc = "VK_EXT_opacity_micromap"]
5876 pub mod opacity_micromap {
5877 use super::super::*;
5878 pub use {
5879 crate::vk::EXT_OPACITY_MICROMAP_NAME as NAME,
5880 crate::vk::EXT_OPACITY_MICROMAP_SPEC_VERSION as SPEC_VERSION,
5881 };
5882 #[doc = "VK_EXT_opacity_micromap device-level functions"]
5883 #[derive(Clone)]
5884 pub struct Device {
5885 pub(crate) fp: DeviceFn,
5886 pub(crate) handle: crate::vk::Device,
5887 }
5888 impl Device {
5889 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
5890 let handle = device.handle();
5891 let fp = DeviceFn::load(|name| unsafe {
5892 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
5893 });
5894 Self { handle, fp }
5895 }
5896 #[inline]
5897 pub fn fp(&self) -> &DeviceFn {
5898 &self.fp
5899 }
5900 #[inline]
5901 pub fn device(&self) -> crate::vk::Device {
5902 self.handle
5903 }
5904 }
5905 #[derive(Clone)]
5906 #[doc = "Raw VK_EXT_opacity_micromap device-level function pointers"]
5907 pub struct DeviceFn {
5908 pub create_micromap_ext: PFN_vkCreateMicromapEXT,
5909 pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT,
5910 pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT,
5911 pub build_micromaps_ext: PFN_vkBuildMicromapsEXT,
5912 pub copy_micromap_ext: PFN_vkCopyMicromapEXT,
5913 pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT,
5914 pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT,
5915 pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT,
5916 pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT,
5917 pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT,
5918 pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT,
5919 pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT,
5920 pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT,
5921 pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT,
5922 }
5923 unsafe impl Send for DeviceFn {}
5924 unsafe impl Sync for DeviceFn {}
5925 impl DeviceFn {
5926 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
5927 Self::load_erased(&mut f)
5928 }
5929 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
5930 Self {
5931 create_micromap_ext: unsafe {
5932 unsafe extern "system" fn create_micromap_ext(
5933 _device: crate::vk::Device,
5934 _p_create_info: *const MicromapCreateInfoEXT<'_>,
5935 _p_allocator: *const AllocationCallbacks<'_>,
5936 _p_micromap: *mut MicromapEXT,
5937 ) -> Result {
5938 panic!(concat!("Unable to load ", stringify!(create_micromap_ext)))
5939 }
5940 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0");
5941 let val = _f(cname);
5942 if val.is_null() {
5943 create_micromap_ext
5944 } else {
5945 ::core::mem::transmute(val)
5946 }
5947 },
5948 destroy_micromap_ext: unsafe {
5949 unsafe extern "system" fn destroy_micromap_ext(
5950 _device: crate::vk::Device,
5951 _micromap: MicromapEXT,
5952 _p_allocator: *const AllocationCallbacks<'_>,
5953 ) {
5954 panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext)))
5955 }
5956 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0");
5957 let val = _f(cname);
5958 if val.is_null() {
5959 destroy_micromap_ext
5960 } else {
5961 ::core::mem::transmute(val)
5962 }
5963 },
5964 cmd_build_micromaps_ext: unsafe {
5965 unsafe extern "system" fn cmd_build_micromaps_ext(
5966 _command_buffer: CommandBuffer,
5967 _info_count: u32,
5968 _p_infos: *const MicromapBuildInfoEXT<'_>,
5969 ) {
5970 panic!(concat!(
5971 "Unable to load ",
5972 stringify!(cmd_build_micromaps_ext)
5973 ))
5974 }
5975 let cname =
5976 CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0");
5977 let val = _f(cname);
5978 if val.is_null() {
5979 cmd_build_micromaps_ext
5980 } else {
5981 ::core::mem::transmute(val)
5982 }
5983 },
5984 build_micromaps_ext: unsafe {
5985 unsafe extern "system" fn build_micromaps_ext(
5986 _device: crate::vk::Device,
5987 _deferred_operation: DeferredOperationKHR,
5988 _info_count: u32,
5989 _p_infos: *const MicromapBuildInfoEXT<'_>,
5990 ) -> Result {
5991 panic!(concat!("Unable to load ", stringify!(build_micromaps_ext)))
5992 }
5993 let cname = CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0");
5994 let val = _f(cname);
5995 if val.is_null() {
5996 build_micromaps_ext
5997 } else {
5998 ::core::mem::transmute(val)
5999 }
6000 },
6001 copy_micromap_ext: unsafe {
6002 unsafe extern "system" fn copy_micromap_ext(
6003 _device: crate::vk::Device,
6004 _deferred_operation: DeferredOperationKHR,
6005 _p_info: *const CopyMicromapInfoEXT<'_>,
6006 ) -> Result {
6007 panic!(concat!("Unable to load ", stringify!(copy_micromap_ext)))
6008 }
6009 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0");
6010 let val = _f(cname);
6011 if val.is_null() {
6012 copy_micromap_ext
6013 } else {
6014 ::core::mem::transmute(val)
6015 }
6016 },
6017 copy_micromap_to_memory_ext: unsafe {
6018 unsafe extern "system" fn copy_micromap_to_memory_ext(
6019 _device: crate::vk::Device,
6020 _deferred_operation: DeferredOperationKHR,
6021 _p_info: *const CopyMicromapToMemoryInfoEXT<'_>,
6022 ) -> Result {
6023 panic!(concat!(
6024 "Unable to load ",
6025 stringify!(copy_micromap_to_memory_ext)
6026 ))
6027 }
6028 let cname =
6029 CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0");
6030 let val = _f(cname);
6031 if val.is_null() {
6032 copy_micromap_to_memory_ext
6033 } else {
6034 ::core::mem::transmute(val)
6035 }
6036 },
6037 copy_memory_to_micromap_ext: unsafe {
6038 unsafe extern "system" fn copy_memory_to_micromap_ext(
6039 _device: crate::vk::Device,
6040 _deferred_operation: DeferredOperationKHR,
6041 _p_info: *const CopyMemoryToMicromapInfoEXT<'_>,
6042 ) -> Result {
6043 panic!(concat!(
6044 "Unable to load ",
6045 stringify!(copy_memory_to_micromap_ext)
6046 ))
6047 }
6048 let cname =
6049 CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0");
6050 let val = _f(cname);
6051 if val.is_null() {
6052 copy_memory_to_micromap_ext
6053 } else {
6054 ::core::mem::transmute(val)
6055 }
6056 },
6057 write_micromaps_properties_ext: unsafe {
6058 unsafe extern "system" fn write_micromaps_properties_ext(
6059 _device: crate::vk::Device,
6060 _micromap_count: u32,
6061 _p_micromaps: *const MicromapEXT,
6062 _query_type: QueryType,
6063 _data_size: usize,
6064 _p_data: *mut c_void,
6065 _stride: usize,
6066 ) -> Result {
6067 panic!(concat!(
6068 "Unable to load ",
6069 stringify!(write_micromaps_properties_ext)
6070 ))
6071 }
6072 let cname =
6073 CStr::from_bytes_with_nul_unchecked(b"vkWriteMicromapsPropertiesEXT\0");
6074 let val = _f(cname);
6075 if val.is_null() {
6076 write_micromaps_properties_ext
6077 } else {
6078 ::core::mem::transmute(val)
6079 }
6080 },
6081 cmd_copy_micromap_ext: unsafe {
6082 unsafe extern "system" fn cmd_copy_micromap_ext(
6083 _command_buffer: CommandBuffer,
6084 _p_info: *const CopyMicromapInfoEXT<'_>,
6085 ) {
6086 panic!(concat!(
6087 "Unable to load ",
6088 stringify!(cmd_copy_micromap_ext)
6089 ))
6090 }
6091 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0");
6092 let val = _f(cname);
6093 if val.is_null() {
6094 cmd_copy_micromap_ext
6095 } else {
6096 ::core::mem::transmute(val)
6097 }
6098 },
6099 cmd_copy_micromap_to_memory_ext: unsafe {
6100 unsafe extern "system" fn cmd_copy_micromap_to_memory_ext(
6101 _command_buffer: CommandBuffer,
6102 _p_info: *const CopyMicromapToMemoryInfoEXT<'_>,
6103 ) {
6104 panic!(concat!(
6105 "Unable to load ",
6106 stringify!(cmd_copy_micromap_to_memory_ext)
6107 ))
6108 }
6109 let cname =
6110 CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapToMemoryEXT\0");
6111 let val = _f(cname);
6112 if val.is_null() {
6113 cmd_copy_micromap_to_memory_ext
6114 } else {
6115 ::core::mem::transmute(val)
6116 }
6117 },
6118 cmd_copy_memory_to_micromap_ext: unsafe {
6119 unsafe extern "system" fn cmd_copy_memory_to_micromap_ext(
6120 _command_buffer: CommandBuffer,
6121 _p_info: *const CopyMemoryToMicromapInfoEXT<'_>,
6122 ) {
6123 panic!(concat!(
6124 "Unable to load ",
6125 stringify!(cmd_copy_memory_to_micromap_ext)
6126 ))
6127 }
6128 let cname =
6129 CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryToMicromapEXT\0");
6130 let val = _f(cname);
6131 if val.is_null() {
6132 cmd_copy_memory_to_micromap_ext
6133 } else {
6134 ::core::mem::transmute(val)
6135 }
6136 },
6137 cmd_write_micromaps_properties_ext: unsafe {
6138 unsafe extern "system" fn cmd_write_micromaps_properties_ext(
6139 _command_buffer: CommandBuffer,
6140 _micromap_count: u32,
6141 _p_micromaps: *const MicromapEXT,
6142 _query_type: QueryType,
6143 _query_pool: QueryPool,
6144 _first_query: u32,
6145 ) {
6146 panic!(concat!(
6147 "Unable to load ",
6148 stringify!(cmd_write_micromaps_properties_ext)
6149 ))
6150 }
6151 let cname = CStr::from_bytes_with_nul_unchecked(
6152 b"vkCmdWriteMicromapsPropertiesEXT\0",
6153 );
6154 let val = _f(cname);
6155 if val.is_null() {
6156 cmd_write_micromaps_properties_ext
6157 } else {
6158 ::core::mem::transmute(val)
6159 }
6160 },
6161 get_device_micromap_compatibility_ext: unsafe {
6162 unsafe extern "system" fn get_device_micromap_compatibility_ext(
6163 _device: crate::vk::Device,
6164 _p_version_info: *const MicromapVersionInfoEXT<'_>,
6165 _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
6166 ) {
6167 panic!(concat!(
6168 "Unable to load ",
6169 stringify!(get_device_micromap_compatibility_ext)
6170 ))
6171 }
6172 let cname = CStr::from_bytes_with_nul_unchecked(
6173 b"vkGetDeviceMicromapCompatibilityEXT\0",
6174 );
6175 let val = _f(cname);
6176 if val.is_null() {
6177 get_device_micromap_compatibility_ext
6178 } else {
6179 ::core::mem::transmute(val)
6180 }
6181 },
6182 get_micromap_build_sizes_ext: unsafe {
6183 unsafe extern "system" fn get_micromap_build_sizes_ext(
6184 _device: crate::vk::Device,
6185 _build_type: AccelerationStructureBuildTypeKHR,
6186 _p_build_info: *const MicromapBuildInfoEXT<'_>,
6187 _p_size_info: *mut MicromapBuildSizesInfoEXT<'_>,
6188 ) {
6189 panic!(concat!(
6190 "Unable to load ",
6191 stringify!(get_micromap_build_sizes_ext)
6192 ))
6193 }
6194 let cname =
6195 CStr::from_bytes_with_nul_unchecked(b"vkGetMicromapBuildSizesEXT\0");
6196 let val = _f(cname);
6197 if val.is_null() {
6198 get_micromap_build_sizes_ext
6199 } else {
6200 ::core::mem::transmute(val)
6201 }
6202 },
6203 }
6204 }
6205 }
6206 }
6207 #[doc = "VK_EXT_load_store_op_none"]
6208 pub mod load_store_op_none {
6209 use super::super::*;
6210 pub use {
6211 crate::vk::EXT_LOAD_STORE_OP_NONE_NAME as NAME,
6212 crate::vk::EXT_LOAD_STORE_OP_NONE_SPEC_VERSION as SPEC_VERSION,
6213 };
6214 }
6215 #[doc = "VK_EXT_border_color_swizzle"]
6216 pub mod border_color_swizzle {
6217 use super::super::*;
6218 pub use {
6219 crate::vk::EXT_BORDER_COLOR_SWIZZLE_NAME as NAME,
6220 crate::vk::EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION as SPEC_VERSION,
6221 };
6222 }
6223 #[doc = "VK_EXT_pageable_device_local_memory"]
6224 pub mod pageable_device_local_memory {
6225 use super::super::*;
6226 pub use {
6227 crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_NAME as NAME,
6228 crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
6229 };
6230 #[doc = "VK_EXT_pageable_device_local_memory device-level functions"]
6231 #[derive(Clone)]
6232 pub struct Device {
6233 pub(crate) fp: DeviceFn,
6234 pub(crate) handle: crate::vk::Device,
6235 }
6236 impl Device {
6237 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
6238 let handle = device.handle();
6239 let fp = DeviceFn::load(|name| unsafe {
6240 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
6241 });
6242 Self { handle, fp }
6243 }
6244 #[inline]
6245 pub fn fp(&self) -> &DeviceFn {
6246 &self.fp
6247 }
6248 #[inline]
6249 pub fn device(&self) -> crate::vk::Device {
6250 self.handle
6251 }
6252 }
6253 #[derive(Clone)]
6254 #[doc = "Raw VK_EXT_pageable_device_local_memory device-level function pointers"]
6255 pub struct DeviceFn {
6256 pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT,
6257 }
6258 unsafe impl Send for DeviceFn {}
6259 unsafe impl Sync for DeviceFn {}
6260 impl DeviceFn {
6261 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
6262 Self::load_erased(&mut f)
6263 }
6264 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
6265 Self {
6266 set_device_memory_priority_ext: unsafe {
6267 unsafe extern "system" fn set_device_memory_priority_ext(
6268 _device: crate::vk::Device,
6269 _memory: DeviceMemory,
6270 _priority: f32,
6271 ) {
6272 panic!(concat!(
6273 "Unable to load ",
6274 stringify!(set_device_memory_priority_ext)
6275 ))
6276 }
6277 let cname =
6278 CStr::from_bytes_with_nul_unchecked(b"vkSetDeviceMemoryPriorityEXT\0");
6279 let val = _f(cname);
6280 if val.is_null() {
6281 set_device_memory_priority_ext
6282 } else {
6283 ::core::mem::transmute(val)
6284 }
6285 },
6286 }
6287 }
6288 }
6289 }
6290 #[doc = "VK_EXT_image_sliced_view_of_3d"]
6291 pub mod image_sliced_view_of_3d {
6292 use super::super::*;
6293 pub use {
6294 crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_NAME as NAME,
6295 crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION,
6296 };
6297 }
6298 #[doc = "VK_EXT_depth_clamp_zero_one"]
6299 pub mod depth_clamp_zero_one {
6300 use super::super::*;
6301 pub use {
6302 crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_NAME as NAME,
6303 crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION as SPEC_VERSION,
6304 };
6305 }
6306 #[doc = "VK_EXT_non_seamless_cube_map"]
6307 pub mod non_seamless_cube_map {
6308 use super::super::*;
6309 pub use {
6310 crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_NAME as NAME,
6311 crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION as SPEC_VERSION,
6312 };
6313 }
6314 #[doc = "VK_EXT_image_compression_control_swapchain"]
6315 pub mod image_compression_control_swapchain {
6316 use super::super::*;
6317 pub use {
6318 crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_NAME as NAME,
6319 crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
6320 };
6321 }
6322 #[doc = "VK_EXT_nested_command_buffer"]
6323 pub mod nested_command_buffer {
6324 use super::super::*;
6325 pub use {
6326 crate::vk::EXT_NESTED_COMMAND_BUFFER_NAME as NAME,
6327 crate::vk::EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION as SPEC_VERSION,
6328 };
6329 }
6330 #[doc = "VK_EXT_external_memory_acquire_unmodified"]
6331 pub mod external_memory_acquire_unmodified {
6332 use super::super::*;
6333 pub use {
6334 crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_NAME as NAME,
6335 crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION as SPEC_VERSION,
6336 };
6337 }
6338 #[doc = "VK_EXT_extended_dynamic_state3"]
6339 pub mod extended_dynamic_state3 {
6340 use super::super::*;
6341 pub use {
6342 crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_NAME as NAME,
6343 crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_SPEC_VERSION as SPEC_VERSION,
6344 };
6345 #[doc = "VK_EXT_extended_dynamic_state3 device-level functions"]
6346 #[derive(Clone)]
6347 pub struct Device {
6348 pub(crate) fp: DeviceFn,
6349 pub(crate) handle: crate::vk::Device,
6350 }
6351 impl Device {
6352 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
6353 let handle = device.handle();
6354 let fp = DeviceFn::load(|name| unsafe {
6355 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
6356 });
6357 Self { handle, fp }
6358 }
6359 #[inline]
6360 pub fn fp(&self) -> &DeviceFn {
6361 &self.fp
6362 }
6363 #[inline]
6364 pub fn device(&self) -> crate::vk::Device {
6365 self.handle
6366 }
6367 }
6368 #[derive(Clone)]
6369 #[doc = "Raw VK_EXT_extended_dynamic_state3 device-level function pointers"]
6370 pub struct DeviceFn {
6371 pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT,
6372 pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT,
6373 pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT,
6374 pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT,
6375 pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT,
6376 pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT,
6377 pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT,
6378 pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT,
6379 pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT,
6380 pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT,
6381 pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT,
6382 pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT,
6383 pub cmd_set_conservative_rasterization_mode_ext:
6384 PFN_vkCmdSetConservativeRasterizationModeEXT,
6385 pub cmd_set_extra_primitive_overestimation_size_ext:
6386 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
6387 pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT,
6388 pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT,
6389 pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT,
6390 pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT,
6391 pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT,
6392 pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT,
6393 pub cmd_set_depth_clip_negative_one_to_one_ext:
6394 PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
6395 pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV,
6396 pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV,
6397 pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV,
6398 pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV,
6399 pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV,
6400 pub cmd_set_coverage_modulation_table_enable_nv:
6401 PFN_vkCmdSetCoverageModulationTableEnableNV,
6402 pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV,
6403 pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV,
6404 pub cmd_set_representative_fragment_test_enable_nv:
6405 PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
6406 pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV,
6407 }
6408 unsafe impl Send for DeviceFn {}
6409 unsafe impl Sync for DeviceFn {}
6410 impl DeviceFn {
6411 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
6412 Self::load_erased(&mut f)
6413 }
6414 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
6415 Self {
6416 cmd_set_depth_clamp_enable_ext: unsafe {
6417 unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
6418 _command_buffer: CommandBuffer,
6419 _depth_clamp_enable: Bool32,
6420 ) {
6421 panic!(concat!(
6422 "Unable to load ",
6423 stringify!(cmd_set_depth_clamp_enable_ext)
6424 ))
6425 }
6426 let cname =
6427 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0");
6428 let val = _f(cname);
6429 if val.is_null() {
6430 cmd_set_depth_clamp_enable_ext
6431 } else {
6432 ::core::mem::transmute(val)
6433 }
6434 },
6435 cmd_set_polygon_mode_ext: unsafe {
6436 unsafe extern "system" fn cmd_set_polygon_mode_ext(
6437 _command_buffer: CommandBuffer,
6438 _polygon_mode: PolygonMode,
6439 ) {
6440 panic!(concat!(
6441 "Unable to load ",
6442 stringify!(cmd_set_polygon_mode_ext)
6443 ))
6444 }
6445 let cname =
6446 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
6447 let val = _f(cname);
6448 if val.is_null() {
6449 cmd_set_polygon_mode_ext
6450 } else {
6451 ::core::mem::transmute(val)
6452 }
6453 },
6454 cmd_set_rasterization_samples_ext: unsafe {
6455 unsafe extern "system" fn cmd_set_rasterization_samples_ext(
6456 _command_buffer: CommandBuffer,
6457 _rasterization_samples: SampleCountFlags,
6458 ) {
6459 panic!(concat!(
6460 "Unable to load ",
6461 stringify!(cmd_set_rasterization_samples_ext)
6462 ))
6463 }
6464 let cname = CStr::from_bytes_with_nul_unchecked(
6465 b"vkCmdSetRasterizationSamplesEXT\0",
6466 );
6467 let val = _f(cname);
6468 if val.is_null() {
6469 cmd_set_rasterization_samples_ext
6470 } else {
6471 ::core::mem::transmute(val)
6472 }
6473 },
6474 cmd_set_sample_mask_ext: unsafe {
6475 unsafe extern "system" fn cmd_set_sample_mask_ext(
6476 _command_buffer: CommandBuffer,
6477 _samples: SampleCountFlags,
6478 _p_sample_mask: *const SampleMask,
6479 ) {
6480 panic!(concat!(
6481 "Unable to load ",
6482 stringify!(cmd_set_sample_mask_ext)
6483 ))
6484 }
6485 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
6486 let val = _f(cname);
6487 if val.is_null() {
6488 cmd_set_sample_mask_ext
6489 } else {
6490 ::core::mem::transmute(val)
6491 }
6492 },
6493 cmd_set_alpha_to_coverage_enable_ext: unsafe {
6494 unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
6495 _command_buffer: CommandBuffer,
6496 _alpha_to_coverage_enable: Bool32,
6497 ) {
6498 panic!(concat!(
6499 "Unable to load ",
6500 stringify!(cmd_set_alpha_to_coverage_enable_ext)
6501 ))
6502 }
6503 let cname = CStr::from_bytes_with_nul_unchecked(
6504 b"vkCmdSetAlphaToCoverageEnableEXT\0",
6505 );
6506 let val = _f(cname);
6507 if val.is_null() {
6508 cmd_set_alpha_to_coverage_enable_ext
6509 } else {
6510 ::core::mem::transmute(val)
6511 }
6512 },
6513 cmd_set_alpha_to_one_enable_ext: unsafe {
6514 unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
6515 _command_buffer: CommandBuffer,
6516 _alpha_to_one_enable: Bool32,
6517 ) {
6518 panic!(concat!(
6519 "Unable to load ",
6520 stringify!(cmd_set_alpha_to_one_enable_ext)
6521 ))
6522 }
6523 let cname =
6524 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetAlphaToOneEnableEXT\0");
6525 let val = _f(cname);
6526 if val.is_null() {
6527 cmd_set_alpha_to_one_enable_ext
6528 } else {
6529 ::core::mem::transmute(val)
6530 }
6531 },
6532 cmd_set_logic_op_enable_ext: unsafe {
6533 unsafe extern "system" fn cmd_set_logic_op_enable_ext(
6534 _command_buffer: CommandBuffer,
6535 _logic_op_enable: Bool32,
6536 ) {
6537 panic!(concat!(
6538 "Unable to load ",
6539 stringify!(cmd_set_logic_op_enable_ext)
6540 ))
6541 }
6542 let cname =
6543 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
6544 let val = _f(cname);
6545 if val.is_null() {
6546 cmd_set_logic_op_enable_ext
6547 } else {
6548 ::core::mem::transmute(val)
6549 }
6550 },
6551 cmd_set_color_blend_enable_ext: unsafe {
6552 unsafe extern "system" fn cmd_set_color_blend_enable_ext(
6553 _command_buffer: CommandBuffer,
6554 _first_attachment: u32,
6555 _attachment_count: u32,
6556 _p_color_blend_enables: *const Bool32,
6557 ) {
6558 panic!(concat!(
6559 "Unable to load ",
6560 stringify!(cmd_set_color_blend_enable_ext)
6561 ))
6562 }
6563 let cname =
6564 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0");
6565 let val = _f(cname);
6566 if val.is_null() {
6567 cmd_set_color_blend_enable_ext
6568 } else {
6569 ::core::mem::transmute(val)
6570 }
6571 },
6572 cmd_set_color_blend_equation_ext: unsafe {
6573 unsafe extern "system" fn cmd_set_color_blend_equation_ext(
6574 _command_buffer: CommandBuffer,
6575 _first_attachment: u32,
6576 _attachment_count: u32,
6577 _p_color_blend_equations: *const ColorBlendEquationEXT,
6578 ) {
6579 panic!(concat!(
6580 "Unable to load ",
6581 stringify!(cmd_set_color_blend_equation_ext)
6582 ))
6583 }
6584 let cname =
6585 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0");
6586 let val = _f(cname);
6587 if val.is_null() {
6588 cmd_set_color_blend_equation_ext
6589 } else {
6590 ::core::mem::transmute(val)
6591 }
6592 },
6593 cmd_set_color_write_mask_ext: unsafe {
6594 unsafe extern "system" fn cmd_set_color_write_mask_ext(
6595 _command_buffer: CommandBuffer,
6596 _first_attachment: u32,
6597 _attachment_count: u32,
6598 _p_color_write_masks: *const ColorComponentFlags,
6599 ) {
6600 panic!(concat!(
6601 "Unable to load ",
6602 stringify!(cmd_set_color_write_mask_ext)
6603 ))
6604 }
6605 let cname =
6606 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
6607 let val = _f(cname);
6608 if val.is_null() {
6609 cmd_set_color_write_mask_ext
6610 } else {
6611 ::core::mem::transmute(val)
6612 }
6613 },
6614 cmd_set_tessellation_domain_origin_ext: unsafe {
6615 unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
6616 _command_buffer: CommandBuffer,
6617 _domain_origin: TessellationDomainOrigin,
6618 ) {
6619 panic!(concat!(
6620 "Unable to load ",
6621 stringify!(cmd_set_tessellation_domain_origin_ext)
6622 ))
6623 }
6624 let cname = CStr::from_bytes_with_nul_unchecked(
6625 b"vkCmdSetTessellationDomainOriginEXT\0",
6626 );
6627 let val = _f(cname);
6628 if val.is_null() {
6629 cmd_set_tessellation_domain_origin_ext
6630 } else {
6631 ::core::mem::transmute(val)
6632 }
6633 },
6634 cmd_set_rasterization_stream_ext: unsafe {
6635 unsafe extern "system" fn cmd_set_rasterization_stream_ext(
6636 _command_buffer: CommandBuffer,
6637 _rasterization_stream: u32,
6638 ) {
6639 panic!(concat!(
6640 "Unable to load ",
6641 stringify!(cmd_set_rasterization_stream_ext)
6642 ))
6643 }
6644 let cname = CStr::from_bytes_with_nul_unchecked(
6645 b"vkCmdSetRasterizationStreamEXT\0",
6646 );
6647 let val = _f(cname);
6648 if val.is_null() {
6649 cmd_set_rasterization_stream_ext
6650 } else {
6651 ::core::mem::transmute(val)
6652 }
6653 },
6654 cmd_set_conservative_rasterization_mode_ext: unsafe {
6655 unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
6656 _command_buffer: CommandBuffer,
6657 _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
6658 ) {
6659 panic!(concat!(
6660 "Unable to load ",
6661 stringify!(cmd_set_conservative_rasterization_mode_ext)
6662 ))
6663 }
6664 let cname = CStr::from_bytes_with_nul_unchecked(
6665 b"vkCmdSetConservativeRasterizationModeEXT\0",
6666 );
6667 let val = _f(cname);
6668 if val.is_null() {
6669 cmd_set_conservative_rasterization_mode_ext
6670 } else {
6671 ::core::mem::transmute(val)
6672 }
6673 },
6674 cmd_set_extra_primitive_overestimation_size_ext: unsafe {
6675 unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
6676 _command_buffer: CommandBuffer,
6677 _extra_primitive_overestimation_size: f32,
6678 ) {
6679 panic!(concat!(
6680 "Unable to load ",
6681 stringify!(cmd_set_extra_primitive_overestimation_size_ext)
6682 ))
6683 }
6684 let cname = CStr::from_bytes_with_nul_unchecked(
6685 b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
6686 );
6687 let val = _f(cname);
6688 if val.is_null() {
6689 cmd_set_extra_primitive_overestimation_size_ext
6690 } else {
6691 ::core::mem::transmute(val)
6692 }
6693 },
6694 cmd_set_depth_clip_enable_ext: unsafe {
6695 unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
6696 _command_buffer: CommandBuffer,
6697 _depth_clip_enable: Bool32,
6698 ) {
6699 panic!(concat!(
6700 "Unable to load ",
6701 stringify!(cmd_set_depth_clip_enable_ext)
6702 ))
6703 }
6704 let cname =
6705 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0");
6706 let val = _f(cname);
6707 if val.is_null() {
6708 cmd_set_depth_clip_enable_ext
6709 } else {
6710 ::core::mem::transmute(val)
6711 }
6712 },
6713 cmd_set_sample_locations_enable_ext: unsafe {
6714 unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
6715 _command_buffer: CommandBuffer,
6716 _sample_locations_enable: Bool32,
6717 ) {
6718 panic!(concat!(
6719 "Unable to load ",
6720 stringify!(cmd_set_sample_locations_enable_ext)
6721 ))
6722 }
6723 let cname = CStr::from_bytes_with_nul_unchecked(
6724 b"vkCmdSetSampleLocationsEnableEXT\0",
6725 );
6726 let val = _f(cname);
6727 if val.is_null() {
6728 cmd_set_sample_locations_enable_ext
6729 } else {
6730 ::core::mem::transmute(val)
6731 }
6732 },
6733 cmd_set_color_blend_advanced_ext: unsafe {
6734 unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
6735 _command_buffer: CommandBuffer,
6736 _first_attachment: u32,
6737 _attachment_count: u32,
6738 _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
6739 ) {
6740 panic!(concat!(
6741 "Unable to load ",
6742 stringify!(cmd_set_color_blend_advanced_ext)
6743 ))
6744 }
6745 let cname =
6746 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0");
6747 let val = _f(cname);
6748 if val.is_null() {
6749 cmd_set_color_blend_advanced_ext
6750 } else {
6751 ::core::mem::transmute(val)
6752 }
6753 },
6754 cmd_set_provoking_vertex_mode_ext: unsafe {
6755 unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
6756 _command_buffer: CommandBuffer,
6757 _provoking_vertex_mode: ProvokingVertexModeEXT,
6758 ) {
6759 panic!(concat!(
6760 "Unable to load ",
6761 stringify!(cmd_set_provoking_vertex_mode_ext)
6762 ))
6763 }
6764 let cname = CStr::from_bytes_with_nul_unchecked(
6765 b"vkCmdSetProvokingVertexModeEXT\0",
6766 );
6767 let val = _f(cname);
6768 if val.is_null() {
6769 cmd_set_provoking_vertex_mode_ext
6770 } else {
6771 ::core::mem::transmute(val)
6772 }
6773 },
6774 cmd_set_line_rasterization_mode_ext: unsafe {
6775 unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
6776 _command_buffer: CommandBuffer,
6777 _line_rasterization_mode: LineRasterizationModeEXT,
6778 ) {
6779 panic!(concat!(
6780 "Unable to load ",
6781 stringify!(cmd_set_line_rasterization_mode_ext)
6782 ))
6783 }
6784 let cname = CStr::from_bytes_with_nul_unchecked(
6785 b"vkCmdSetLineRasterizationModeEXT\0",
6786 );
6787 let val = _f(cname);
6788 if val.is_null() {
6789 cmd_set_line_rasterization_mode_ext
6790 } else {
6791 ::core::mem::transmute(val)
6792 }
6793 },
6794 cmd_set_line_stipple_enable_ext: unsafe {
6795 unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
6796 _command_buffer: CommandBuffer,
6797 _stippled_line_enable: Bool32,
6798 ) {
6799 panic!(concat!(
6800 "Unable to load ",
6801 stringify!(cmd_set_line_stipple_enable_ext)
6802 ))
6803 }
6804 let cname =
6805 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0");
6806 let val = _f(cname);
6807 if val.is_null() {
6808 cmd_set_line_stipple_enable_ext
6809 } else {
6810 ::core::mem::transmute(val)
6811 }
6812 },
6813 cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
6814 unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
6815 _command_buffer: CommandBuffer,
6816 _negative_one_to_one: Bool32,
6817 ) {
6818 panic!(concat!(
6819 "Unable to load ",
6820 stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
6821 ))
6822 }
6823 let cname = CStr::from_bytes_with_nul_unchecked(
6824 b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
6825 );
6826 let val = _f(cname);
6827 if val.is_null() {
6828 cmd_set_depth_clip_negative_one_to_one_ext
6829 } else {
6830 ::core::mem::transmute(val)
6831 }
6832 },
6833 cmd_set_viewport_w_scaling_enable_nv: unsafe {
6834 unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
6835 _command_buffer: CommandBuffer,
6836 _viewport_w_scaling_enable: Bool32,
6837 ) {
6838 panic!(concat!(
6839 "Unable to load ",
6840 stringify!(cmd_set_viewport_w_scaling_enable_nv)
6841 ))
6842 }
6843 let cname = CStr::from_bytes_with_nul_unchecked(
6844 b"vkCmdSetViewportWScalingEnableNV\0",
6845 );
6846 let val = _f(cname);
6847 if val.is_null() {
6848 cmd_set_viewport_w_scaling_enable_nv
6849 } else {
6850 ::core::mem::transmute(val)
6851 }
6852 },
6853 cmd_set_viewport_swizzle_nv: unsafe {
6854 unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
6855 _command_buffer: CommandBuffer,
6856 _first_viewport: u32,
6857 _viewport_count: u32,
6858 _p_viewport_swizzles: *const ViewportSwizzleNV,
6859 ) {
6860 panic!(concat!(
6861 "Unable to load ",
6862 stringify!(cmd_set_viewport_swizzle_nv)
6863 ))
6864 }
6865 let cname =
6866 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
6867 let val = _f(cname);
6868 if val.is_null() {
6869 cmd_set_viewport_swizzle_nv
6870 } else {
6871 ::core::mem::transmute(val)
6872 }
6873 },
6874 cmd_set_coverage_to_color_enable_nv: unsafe {
6875 unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
6876 _command_buffer: CommandBuffer,
6877 _coverage_to_color_enable: Bool32,
6878 ) {
6879 panic!(concat!(
6880 "Unable to load ",
6881 stringify!(cmd_set_coverage_to_color_enable_nv)
6882 ))
6883 }
6884 let cname = CStr::from_bytes_with_nul_unchecked(
6885 b"vkCmdSetCoverageToColorEnableNV\0",
6886 );
6887 let val = _f(cname);
6888 if val.is_null() {
6889 cmd_set_coverage_to_color_enable_nv
6890 } else {
6891 ::core::mem::transmute(val)
6892 }
6893 },
6894 cmd_set_coverage_to_color_location_nv: unsafe {
6895 unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
6896 _command_buffer: CommandBuffer,
6897 _coverage_to_color_location: u32,
6898 ) {
6899 panic!(concat!(
6900 "Unable to load ",
6901 stringify!(cmd_set_coverage_to_color_location_nv)
6902 ))
6903 }
6904 let cname = CStr::from_bytes_with_nul_unchecked(
6905 b"vkCmdSetCoverageToColorLocationNV\0",
6906 );
6907 let val = _f(cname);
6908 if val.is_null() {
6909 cmd_set_coverage_to_color_location_nv
6910 } else {
6911 ::core::mem::transmute(val)
6912 }
6913 },
6914 cmd_set_coverage_modulation_mode_nv: unsafe {
6915 unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
6916 _command_buffer: CommandBuffer,
6917 _coverage_modulation_mode: CoverageModulationModeNV,
6918 ) {
6919 panic!(concat!(
6920 "Unable to load ",
6921 stringify!(cmd_set_coverage_modulation_mode_nv)
6922 ))
6923 }
6924 let cname = CStr::from_bytes_with_nul_unchecked(
6925 b"vkCmdSetCoverageModulationModeNV\0",
6926 );
6927 let val = _f(cname);
6928 if val.is_null() {
6929 cmd_set_coverage_modulation_mode_nv
6930 } else {
6931 ::core::mem::transmute(val)
6932 }
6933 },
6934 cmd_set_coverage_modulation_table_enable_nv: unsafe {
6935 unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
6936 _command_buffer: CommandBuffer,
6937 _coverage_modulation_table_enable: Bool32,
6938 ) {
6939 panic!(concat!(
6940 "Unable to load ",
6941 stringify!(cmd_set_coverage_modulation_table_enable_nv)
6942 ))
6943 }
6944 let cname = CStr::from_bytes_with_nul_unchecked(
6945 b"vkCmdSetCoverageModulationTableEnableNV\0",
6946 );
6947 let val = _f(cname);
6948 if val.is_null() {
6949 cmd_set_coverage_modulation_table_enable_nv
6950 } else {
6951 ::core::mem::transmute(val)
6952 }
6953 },
6954 cmd_set_coverage_modulation_table_nv: unsafe {
6955 unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
6956 _command_buffer: CommandBuffer,
6957 _coverage_modulation_table_count: u32,
6958 _p_coverage_modulation_table: *const f32,
6959 ) {
6960 panic!(concat!(
6961 "Unable to load ",
6962 stringify!(cmd_set_coverage_modulation_table_nv)
6963 ))
6964 }
6965 let cname = CStr::from_bytes_with_nul_unchecked(
6966 b"vkCmdSetCoverageModulationTableNV\0",
6967 );
6968 let val = _f(cname);
6969 if val.is_null() {
6970 cmd_set_coverage_modulation_table_nv
6971 } else {
6972 ::core::mem::transmute(val)
6973 }
6974 },
6975 cmd_set_shading_rate_image_enable_nv: unsafe {
6976 unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
6977 _command_buffer: CommandBuffer,
6978 _shading_rate_image_enable: Bool32,
6979 ) {
6980 panic!(concat!(
6981 "Unable to load ",
6982 stringify!(cmd_set_shading_rate_image_enable_nv)
6983 ))
6984 }
6985 let cname = CStr::from_bytes_with_nul_unchecked(
6986 b"vkCmdSetShadingRateImageEnableNV\0",
6987 );
6988 let val = _f(cname);
6989 if val.is_null() {
6990 cmd_set_shading_rate_image_enable_nv
6991 } else {
6992 ::core::mem::transmute(val)
6993 }
6994 },
6995 cmd_set_representative_fragment_test_enable_nv: unsafe {
6996 unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
6997 _command_buffer: CommandBuffer,
6998 _representative_fragment_test_enable: Bool32,
6999 ) {
7000 panic!(concat!(
7001 "Unable to load ",
7002 stringify!(cmd_set_representative_fragment_test_enable_nv)
7003 ))
7004 }
7005 let cname = CStr::from_bytes_with_nul_unchecked(
7006 b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
7007 );
7008 let val = _f(cname);
7009 if val.is_null() {
7010 cmd_set_representative_fragment_test_enable_nv
7011 } else {
7012 ::core::mem::transmute(val)
7013 }
7014 },
7015 cmd_set_coverage_reduction_mode_nv: unsafe {
7016 unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
7017 _command_buffer: CommandBuffer,
7018 _coverage_reduction_mode: CoverageReductionModeNV,
7019 ) {
7020 panic!(concat!(
7021 "Unable to load ",
7022 stringify!(cmd_set_coverage_reduction_mode_nv)
7023 ))
7024 }
7025 let cname = CStr::from_bytes_with_nul_unchecked(
7026 b"vkCmdSetCoverageReductionModeNV\0",
7027 );
7028 let val = _f(cname);
7029 if val.is_null() {
7030 cmd_set_coverage_reduction_mode_nv
7031 } else {
7032 ::core::mem::transmute(val)
7033 }
7034 },
7035 }
7036 }
7037 }
7038 }
7039 #[doc = "VK_EXT_subpass_merge_feedback"]
7040 pub mod subpass_merge_feedback {
7041 use super::super::*;
7042 pub use {
7043 crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_NAME as NAME,
7044 crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
7045 };
7046 }
7047 #[doc = "VK_EXT_shader_module_identifier"]
7048 pub mod shader_module_identifier {
7049 use super::super::*;
7050 pub use {
7051 crate::vk::EXT_SHADER_MODULE_IDENTIFIER_NAME as NAME,
7052 crate::vk::EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION as SPEC_VERSION,
7053 };
7054 #[doc = "VK_EXT_shader_module_identifier device-level functions"]
7055 #[derive(Clone)]
7056 pub struct Device {
7057 pub(crate) fp: DeviceFn,
7058 pub(crate) handle: crate::vk::Device,
7059 }
7060 impl Device {
7061 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
7062 let handle = device.handle();
7063 let fp = DeviceFn::load(|name| unsafe {
7064 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
7065 });
7066 Self { handle, fp }
7067 }
7068 #[inline]
7069 pub fn fp(&self) -> &DeviceFn {
7070 &self.fp
7071 }
7072 #[inline]
7073 pub fn device(&self) -> crate::vk::Device {
7074 self.handle
7075 }
7076 }
7077 #[derive(Clone)]
7078 #[doc = "Raw VK_EXT_shader_module_identifier device-level function pointers"]
7079 pub struct DeviceFn {
7080 pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT,
7081 pub get_shader_module_create_info_identifier_ext:
7082 PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
7083 }
7084 unsafe impl Send for DeviceFn {}
7085 unsafe impl Sync for DeviceFn {}
7086 impl DeviceFn {
7087 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
7088 Self::load_erased(&mut f)
7089 }
7090 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
7091 Self {
7092 get_shader_module_identifier_ext: unsafe {
7093 unsafe extern "system" fn get_shader_module_identifier_ext(
7094 _device: crate::vk::Device,
7095 _shader_module: ShaderModule,
7096 _p_identifier: *mut ShaderModuleIdentifierEXT<'_>,
7097 ) {
7098 panic!(concat!(
7099 "Unable to load ",
7100 stringify!(get_shader_module_identifier_ext)
7101 ))
7102 }
7103 let cname = CStr::from_bytes_with_nul_unchecked(
7104 b"vkGetShaderModuleIdentifierEXT\0",
7105 );
7106 let val = _f(cname);
7107 if val.is_null() {
7108 get_shader_module_identifier_ext
7109 } else {
7110 ::core::mem::transmute(val)
7111 }
7112 },
7113 get_shader_module_create_info_identifier_ext: unsafe {
7114 unsafe extern "system" fn get_shader_module_create_info_identifier_ext(
7115 _device: crate::vk::Device,
7116 _p_create_info: *const ShaderModuleCreateInfo<'_>,
7117 _p_identifier: *mut ShaderModuleIdentifierEXT<'_>,
7118 ) {
7119 panic!(concat!(
7120 "Unable to load ",
7121 stringify!(get_shader_module_create_info_identifier_ext)
7122 ))
7123 }
7124 let cname = CStr::from_bytes_with_nul_unchecked(
7125 b"vkGetShaderModuleCreateInfoIdentifierEXT\0",
7126 );
7127 let val = _f(cname);
7128 if val.is_null() {
7129 get_shader_module_create_info_identifier_ext
7130 } else {
7131 ::core::mem::transmute(val)
7132 }
7133 },
7134 }
7135 }
7136 }
7137 }
7138 #[doc = "VK_EXT_rasterization_order_attachment_access"]
7139 pub mod rasterization_order_attachment_access {
7140 use super::super::*;
7141 pub use {
7142 crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME,
7143 crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION,
7144 };
7145 }
7146 #[doc = "VK_EXT_legacy_dithering"]
7147 pub mod legacy_dithering {
7148 use super::super::*;
7149 pub use {
7150 crate::vk::EXT_LEGACY_DITHERING_NAME as NAME,
7151 crate::vk::EXT_LEGACY_DITHERING_SPEC_VERSION as SPEC_VERSION,
7152 };
7153 }
7154 #[doc = "VK_EXT_pipeline_protected_access"]
7155 pub mod pipeline_protected_access {
7156 use super::super::*;
7157 pub use {
7158 crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_NAME as NAME,
7159 crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION as SPEC_VERSION,
7160 };
7161 }
7162 #[doc = "VK_EXT_shader_object"]
7163 pub mod shader_object {
7164 use super::super::*;
7165 pub use {
7166 crate::vk::EXT_SHADER_OBJECT_NAME as NAME,
7167 crate::vk::EXT_SHADER_OBJECT_SPEC_VERSION as SPEC_VERSION,
7168 };
7169 #[doc = "VK_EXT_shader_object device-level functions"]
7170 #[derive(Clone)]
7171 pub struct Device {
7172 pub(crate) fp: DeviceFn,
7173 pub(crate) handle: crate::vk::Device,
7174 }
7175 impl Device {
7176 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
7177 let handle = device.handle();
7178 let fp = DeviceFn::load(|name| unsafe {
7179 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
7180 });
7181 Self { handle, fp }
7182 }
7183 #[inline]
7184 pub fn fp(&self) -> &DeviceFn {
7185 &self.fp
7186 }
7187 #[inline]
7188 pub fn device(&self) -> crate::vk::Device {
7189 self.handle
7190 }
7191 }
7192 #[derive(Clone)]
7193 #[doc = "Raw VK_EXT_shader_object device-level function pointers"]
7194 pub struct DeviceFn {
7195 pub create_shaders_ext: PFN_vkCreateShadersEXT,
7196 pub destroy_shader_ext: PFN_vkDestroyShaderEXT,
7197 pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT,
7198 pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT,
7199 pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode,
7200 pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace,
7201 pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology,
7202 pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount,
7203 pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount,
7204 pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2,
7205 pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable,
7206 pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable,
7207 pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp,
7208 pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable,
7209 pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable,
7210 pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp,
7211 pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
7212 pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT,
7213 pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable,
7214 pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable,
7215 pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT,
7216 pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable,
7217 pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT,
7218 pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT,
7219 pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT,
7220 pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT,
7221 pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT,
7222 pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT,
7223 pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT,
7224 pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT,
7225 pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT,
7226 pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT,
7227 pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT,
7228 pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT,
7229 pub cmd_set_conservative_rasterization_mode_ext:
7230 PFN_vkCmdSetConservativeRasterizationModeEXT,
7231 pub cmd_set_extra_primitive_overestimation_size_ext:
7232 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
7233 pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT,
7234 pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT,
7235 pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT,
7236 pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT,
7237 pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT,
7238 pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT,
7239 pub cmd_set_depth_clip_negative_one_to_one_ext:
7240 PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
7241 pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV,
7242 pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV,
7243 pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV,
7244 pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV,
7245 pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV,
7246 pub cmd_set_coverage_modulation_table_enable_nv:
7247 PFN_vkCmdSetCoverageModulationTableEnableNV,
7248 pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV,
7249 pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV,
7250 pub cmd_set_representative_fragment_test_enable_nv:
7251 PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
7252 pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV,
7253 }
7254 unsafe impl Send for DeviceFn {}
7255 unsafe impl Sync for DeviceFn {}
7256 impl DeviceFn {
7257 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
7258 Self::load_erased(&mut f)
7259 }
7260 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
7261 Self {
7262 create_shaders_ext: unsafe {
7263 unsafe extern "system" fn create_shaders_ext(
7264 _device: crate::vk::Device,
7265 _create_info_count: u32,
7266 _p_create_infos: *const ShaderCreateInfoEXT<'_>,
7267 _p_allocator: *const AllocationCallbacks<'_>,
7268 _p_shaders: *mut ShaderEXT,
7269 ) -> Result {
7270 panic!(concat!("Unable to load ", stringify!(create_shaders_ext)))
7271 }
7272 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0");
7273 let val = _f(cname);
7274 if val.is_null() {
7275 create_shaders_ext
7276 } else {
7277 ::core::mem::transmute(val)
7278 }
7279 },
7280 destroy_shader_ext: unsafe {
7281 unsafe extern "system" fn destroy_shader_ext(
7282 _device: crate::vk::Device,
7283 _shader: ShaderEXT,
7284 _p_allocator: *const AllocationCallbacks<'_>,
7285 ) {
7286 panic!(concat!("Unable to load ", stringify!(destroy_shader_ext)))
7287 }
7288 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0");
7289 let val = _f(cname);
7290 if val.is_null() {
7291 destroy_shader_ext
7292 } else {
7293 ::core::mem::transmute(val)
7294 }
7295 },
7296 get_shader_binary_data_ext: unsafe {
7297 unsafe extern "system" fn get_shader_binary_data_ext(
7298 _device: crate::vk::Device,
7299 _shader: ShaderEXT,
7300 _p_data_size: *mut usize,
7301 _p_data: *mut c_void,
7302 ) -> Result {
7303 panic!(concat!(
7304 "Unable to load ",
7305 stringify!(get_shader_binary_data_ext)
7306 ))
7307 }
7308 let cname =
7309 CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0");
7310 let val = _f(cname);
7311 if val.is_null() {
7312 get_shader_binary_data_ext
7313 } else {
7314 ::core::mem::transmute(val)
7315 }
7316 },
7317 cmd_bind_shaders_ext: unsafe {
7318 unsafe extern "system" fn cmd_bind_shaders_ext(
7319 _command_buffer: CommandBuffer,
7320 _stage_count: u32,
7321 _p_stages: *const ShaderStageFlags,
7322 _p_shaders: *const ShaderEXT,
7323 ) {
7324 panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext)))
7325 }
7326 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0");
7327 let val = _f(cname);
7328 if val.is_null() {
7329 cmd_bind_shaders_ext
7330 } else {
7331 ::core::mem::transmute(val)
7332 }
7333 },
7334 cmd_set_cull_mode_ext: unsafe {
7335 unsafe extern "system" fn cmd_set_cull_mode_ext(
7336 _command_buffer: CommandBuffer,
7337 _cull_mode: CullModeFlags,
7338 ) {
7339 panic!(concat!(
7340 "Unable to load ",
7341 stringify!(cmd_set_cull_mode_ext)
7342 ))
7343 }
7344 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
7345 let val = _f(cname);
7346 if val.is_null() {
7347 cmd_set_cull_mode_ext
7348 } else {
7349 ::core::mem::transmute(val)
7350 }
7351 },
7352 cmd_set_front_face_ext: unsafe {
7353 unsafe extern "system" fn cmd_set_front_face_ext(
7354 _command_buffer: CommandBuffer,
7355 _front_face: FrontFace,
7356 ) {
7357 panic!(concat!(
7358 "Unable to load ",
7359 stringify!(cmd_set_front_face_ext)
7360 ))
7361 }
7362 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
7363 let val = _f(cname);
7364 if val.is_null() {
7365 cmd_set_front_face_ext
7366 } else {
7367 ::core::mem::transmute(val)
7368 }
7369 },
7370 cmd_set_primitive_topology_ext: unsafe {
7371 unsafe extern "system" fn cmd_set_primitive_topology_ext(
7372 _command_buffer: CommandBuffer,
7373 _primitive_topology: PrimitiveTopology,
7374 ) {
7375 panic!(concat!(
7376 "Unable to load ",
7377 stringify!(cmd_set_primitive_topology_ext)
7378 ))
7379 }
7380 let cname =
7381 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0");
7382 let val = _f(cname);
7383 if val.is_null() {
7384 cmd_set_primitive_topology_ext
7385 } else {
7386 ::core::mem::transmute(val)
7387 }
7388 },
7389 cmd_set_viewport_with_count_ext: unsafe {
7390 unsafe extern "system" fn cmd_set_viewport_with_count_ext(
7391 _command_buffer: CommandBuffer,
7392 _viewport_count: u32,
7393 _p_viewports: *const Viewport,
7394 ) {
7395 panic!(concat!(
7396 "Unable to load ",
7397 stringify!(cmd_set_viewport_with_count_ext)
7398 ))
7399 }
7400 let cname =
7401 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0");
7402 let val = _f(cname);
7403 if val.is_null() {
7404 cmd_set_viewport_with_count_ext
7405 } else {
7406 ::core::mem::transmute(val)
7407 }
7408 },
7409 cmd_set_scissor_with_count_ext: unsafe {
7410 unsafe extern "system" fn cmd_set_scissor_with_count_ext(
7411 _command_buffer: CommandBuffer,
7412 _scissor_count: u32,
7413 _p_scissors: *const Rect2D,
7414 ) {
7415 panic!(concat!(
7416 "Unable to load ",
7417 stringify!(cmd_set_scissor_with_count_ext)
7418 ))
7419 }
7420 let cname =
7421 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0");
7422 let val = _f(cname);
7423 if val.is_null() {
7424 cmd_set_scissor_with_count_ext
7425 } else {
7426 ::core::mem::transmute(val)
7427 }
7428 },
7429 cmd_bind_vertex_buffers2_ext: unsafe {
7430 unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
7431 _command_buffer: CommandBuffer,
7432 _first_binding: u32,
7433 _binding_count: u32,
7434 _p_buffers: *const Buffer,
7435 _p_offsets: *const DeviceSize,
7436 _p_sizes: *const DeviceSize,
7437 _p_strides: *const DeviceSize,
7438 ) {
7439 panic!(concat!(
7440 "Unable to load ",
7441 stringify!(cmd_bind_vertex_buffers2_ext)
7442 ))
7443 }
7444 let cname =
7445 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0");
7446 let val = _f(cname);
7447 if val.is_null() {
7448 cmd_bind_vertex_buffers2_ext
7449 } else {
7450 ::core::mem::transmute(val)
7451 }
7452 },
7453 cmd_set_depth_test_enable_ext: unsafe {
7454 unsafe extern "system" fn cmd_set_depth_test_enable_ext(
7455 _command_buffer: CommandBuffer,
7456 _depth_test_enable: Bool32,
7457 ) {
7458 panic!(concat!(
7459 "Unable to load ",
7460 stringify!(cmd_set_depth_test_enable_ext)
7461 ))
7462 }
7463 let cname =
7464 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0");
7465 let val = _f(cname);
7466 if val.is_null() {
7467 cmd_set_depth_test_enable_ext
7468 } else {
7469 ::core::mem::transmute(val)
7470 }
7471 },
7472 cmd_set_depth_write_enable_ext: unsafe {
7473 unsafe extern "system" fn cmd_set_depth_write_enable_ext(
7474 _command_buffer: CommandBuffer,
7475 _depth_write_enable: Bool32,
7476 ) {
7477 panic!(concat!(
7478 "Unable to load ",
7479 stringify!(cmd_set_depth_write_enable_ext)
7480 ))
7481 }
7482 let cname =
7483 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0");
7484 let val = _f(cname);
7485 if val.is_null() {
7486 cmd_set_depth_write_enable_ext
7487 } else {
7488 ::core::mem::transmute(val)
7489 }
7490 },
7491 cmd_set_depth_compare_op_ext: unsafe {
7492 unsafe extern "system" fn cmd_set_depth_compare_op_ext(
7493 _command_buffer: CommandBuffer,
7494 _depth_compare_op: CompareOp,
7495 ) {
7496 panic!(concat!(
7497 "Unable to load ",
7498 stringify!(cmd_set_depth_compare_op_ext)
7499 ))
7500 }
7501 let cname =
7502 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
7503 let val = _f(cname);
7504 if val.is_null() {
7505 cmd_set_depth_compare_op_ext
7506 } else {
7507 ::core::mem::transmute(val)
7508 }
7509 },
7510 cmd_set_depth_bounds_test_enable_ext: unsafe {
7511 unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
7512 _command_buffer: CommandBuffer,
7513 _depth_bounds_test_enable: Bool32,
7514 ) {
7515 panic!(concat!(
7516 "Unable to load ",
7517 stringify!(cmd_set_depth_bounds_test_enable_ext)
7518 ))
7519 }
7520 let cname = CStr::from_bytes_with_nul_unchecked(
7521 b"vkCmdSetDepthBoundsTestEnableEXT\0",
7522 );
7523 let val = _f(cname);
7524 if val.is_null() {
7525 cmd_set_depth_bounds_test_enable_ext
7526 } else {
7527 ::core::mem::transmute(val)
7528 }
7529 },
7530 cmd_set_stencil_test_enable_ext: unsafe {
7531 unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
7532 _command_buffer: CommandBuffer,
7533 _stencil_test_enable: Bool32,
7534 ) {
7535 panic!(concat!(
7536 "Unable to load ",
7537 stringify!(cmd_set_stencil_test_enable_ext)
7538 ))
7539 }
7540 let cname =
7541 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0");
7542 let val = _f(cname);
7543 if val.is_null() {
7544 cmd_set_stencil_test_enable_ext
7545 } else {
7546 ::core::mem::transmute(val)
7547 }
7548 },
7549 cmd_set_stencil_op_ext: unsafe {
7550 unsafe extern "system" fn cmd_set_stencil_op_ext(
7551 _command_buffer: CommandBuffer,
7552 _face_mask: StencilFaceFlags,
7553 _fail_op: StencilOp,
7554 _pass_op: StencilOp,
7555 _depth_fail_op: StencilOp,
7556 _compare_op: CompareOp,
7557 ) {
7558 panic!(concat!(
7559 "Unable to load ",
7560 stringify!(cmd_set_stencil_op_ext)
7561 ))
7562 }
7563 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
7564 let val = _f(cname);
7565 if val.is_null() {
7566 cmd_set_stencil_op_ext
7567 } else {
7568 ::core::mem::transmute(val)
7569 }
7570 },
7571 cmd_set_vertex_input_ext: unsafe {
7572 unsafe extern "system" fn cmd_set_vertex_input_ext(
7573 _command_buffer: CommandBuffer,
7574 _vertex_binding_description_count: u32,
7575 _p_vertex_binding_descriptions : * const VertexInputBindingDescription2EXT < '_ >,
7576 _vertex_attribute_description_count: u32,
7577 _p_vertex_attribute_descriptions : * const VertexInputAttributeDescription2EXT < '_ >,
7578 ) {
7579 panic!(concat!(
7580 "Unable to load ",
7581 stringify!(cmd_set_vertex_input_ext)
7582 ))
7583 }
7584 let cname =
7585 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
7586 let val = _f(cname);
7587 if val.is_null() {
7588 cmd_set_vertex_input_ext
7589 } else {
7590 ::core::mem::transmute(val)
7591 }
7592 },
7593 cmd_set_patch_control_points_ext: unsafe {
7594 unsafe extern "system" fn cmd_set_patch_control_points_ext(
7595 _command_buffer: CommandBuffer,
7596 _patch_control_points: u32,
7597 ) {
7598 panic!(concat!(
7599 "Unable to load ",
7600 stringify!(cmd_set_patch_control_points_ext)
7601 ))
7602 }
7603 let cname =
7604 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0");
7605 let val = _f(cname);
7606 if val.is_null() {
7607 cmd_set_patch_control_points_ext
7608 } else {
7609 ::core::mem::transmute(val)
7610 }
7611 },
7612 cmd_set_rasterizer_discard_enable_ext: unsafe {
7613 unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
7614 _command_buffer: CommandBuffer,
7615 _rasterizer_discard_enable: Bool32,
7616 ) {
7617 panic!(concat!(
7618 "Unable to load ",
7619 stringify!(cmd_set_rasterizer_discard_enable_ext)
7620 ))
7621 }
7622 let cname = CStr::from_bytes_with_nul_unchecked(
7623 b"vkCmdSetRasterizerDiscardEnableEXT\0",
7624 );
7625 let val = _f(cname);
7626 if val.is_null() {
7627 cmd_set_rasterizer_discard_enable_ext
7628 } else {
7629 ::core::mem::transmute(val)
7630 }
7631 },
7632 cmd_set_depth_bias_enable_ext: unsafe {
7633 unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
7634 _command_buffer: CommandBuffer,
7635 _depth_bias_enable: Bool32,
7636 ) {
7637 panic!(concat!(
7638 "Unable to load ",
7639 stringify!(cmd_set_depth_bias_enable_ext)
7640 ))
7641 }
7642 let cname =
7643 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0");
7644 let val = _f(cname);
7645 if val.is_null() {
7646 cmd_set_depth_bias_enable_ext
7647 } else {
7648 ::core::mem::transmute(val)
7649 }
7650 },
7651 cmd_set_logic_op_ext: unsafe {
7652 unsafe extern "system" fn cmd_set_logic_op_ext(
7653 _command_buffer: CommandBuffer,
7654 _logic_op: LogicOp,
7655 ) {
7656 panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
7657 }
7658 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
7659 let val = _f(cname);
7660 if val.is_null() {
7661 cmd_set_logic_op_ext
7662 } else {
7663 ::core::mem::transmute(val)
7664 }
7665 },
7666 cmd_set_primitive_restart_enable_ext: unsafe {
7667 unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
7668 _command_buffer: CommandBuffer,
7669 _primitive_restart_enable: Bool32,
7670 ) {
7671 panic!(concat!(
7672 "Unable to load ",
7673 stringify!(cmd_set_primitive_restart_enable_ext)
7674 ))
7675 }
7676 let cname = CStr::from_bytes_with_nul_unchecked(
7677 b"vkCmdSetPrimitiveRestartEnableEXT\0",
7678 );
7679 let val = _f(cname);
7680 if val.is_null() {
7681 cmd_set_primitive_restart_enable_ext
7682 } else {
7683 ::core::mem::transmute(val)
7684 }
7685 },
7686 cmd_set_tessellation_domain_origin_ext: unsafe {
7687 unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
7688 _command_buffer: CommandBuffer,
7689 _domain_origin: TessellationDomainOrigin,
7690 ) {
7691 panic!(concat!(
7692 "Unable to load ",
7693 stringify!(cmd_set_tessellation_domain_origin_ext)
7694 ))
7695 }
7696 let cname = CStr::from_bytes_with_nul_unchecked(
7697 b"vkCmdSetTessellationDomainOriginEXT\0",
7698 );
7699 let val = _f(cname);
7700 if val.is_null() {
7701 cmd_set_tessellation_domain_origin_ext
7702 } else {
7703 ::core::mem::transmute(val)
7704 }
7705 },
7706 cmd_set_depth_clamp_enable_ext: unsafe {
7707 unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
7708 _command_buffer: CommandBuffer,
7709 _depth_clamp_enable: Bool32,
7710 ) {
7711 panic!(concat!(
7712 "Unable to load ",
7713 stringify!(cmd_set_depth_clamp_enable_ext)
7714 ))
7715 }
7716 let cname =
7717 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0");
7718 let val = _f(cname);
7719 if val.is_null() {
7720 cmd_set_depth_clamp_enable_ext
7721 } else {
7722 ::core::mem::transmute(val)
7723 }
7724 },
7725 cmd_set_polygon_mode_ext: unsafe {
7726 unsafe extern "system" fn cmd_set_polygon_mode_ext(
7727 _command_buffer: CommandBuffer,
7728 _polygon_mode: PolygonMode,
7729 ) {
7730 panic!(concat!(
7731 "Unable to load ",
7732 stringify!(cmd_set_polygon_mode_ext)
7733 ))
7734 }
7735 let cname =
7736 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
7737 let val = _f(cname);
7738 if val.is_null() {
7739 cmd_set_polygon_mode_ext
7740 } else {
7741 ::core::mem::transmute(val)
7742 }
7743 },
7744 cmd_set_rasterization_samples_ext: unsafe {
7745 unsafe extern "system" fn cmd_set_rasterization_samples_ext(
7746 _command_buffer: CommandBuffer,
7747 _rasterization_samples: SampleCountFlags,
7748 ) {
7749 panic!(concat!(
7750 "Unable to load ",
7751 stringify!(cmd_set_rasterization_samples_ext)
7752 ))
7753 }
7754 let cname = CStr::from_bytes_with_nul_unchecked(
7755 b"vkCmdSetRasterizationSamplesEXT\0",
7756 );
7757 let val = _f(cname);
7758 if val.is_null() {
7759 cmd_set_rasterization_samples_ext
7760 } else {
7761 ::core::mem::transmute(val)
7762 }
7763 },
7764 cmd_set_sample_mask_ext: unsafe {
7765 unsafe extern "system" fn cmd_set_sample_mask_ext(
7766 _command_buffer: CommandBuffer,
7767 _samples: SampleCountFlags,
7768 _p_sample_mask: *const SampleMask,
7769 ) {
7770 panic!(concat!(
7771 "Unable to load ",
7772 stringify!(cmd_set_sample_mask_ext)
7773 ))
7774 }
7775 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
7776 let val = _f(cname);
7777 if val.is_null() {
7778 cmd_set_sample_mask_ext
7779 } else {
7780 ::core::mem::transmute(val)
7781 }
7782 },
7783 cmd_set_alpha_to_coverage_enable_ext: unsafe {
7784 unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
7785 _command_buffer: CommandBuffer,
7786 _alpha_to_coverage_enable: Bool32,
7787 ) {
7788 panic!(concat!(
7789 "Unable to load ",
7790 stringify!(cmd_set_alpha_to_coverage_enable_ext)
7791 ))
7792 }
7793 let cname = CStr::from_bytes_with_nul_unchecked(
7794 b"vkCmdSetAlphaToCoverageEnableEXT\0",
7795 );
7796 let val = _f(cname);
7797 if val.is_null() {
7798 cmd_set_alpha_to_coverage_enable_ext
7799 } else {
7800 ::core::mem::transmute(val)
7801 }
7802 },
7803 cmd_set_alpha_to_one_enable_ext: unsafe {
7804 unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
7805 _command_buffer: CommandBuffer,
7806 _alpha_to_one_enable: Bool32,
7807 ) {
7808 panic!(concat!(
7809 "Unable to load ",
7810 stringify!(cmd_set_alpha_to_one_enable_ext)
7811 ))
7812 }
7813 let cname =
7814 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetAlphaToOneEnableEXT\0");
7815 let val = _f(cname);
7816 if val.is_null() {
7817 cmd_set_alpha_to_one_enable_ext
7818 } else {
7819 ::core::mem::transmute(val)
7820 }
7821 },
7822 cmd_set_logic_op_enable_ext: unsafe {
7823 unsafe extern "system" fn cmd_set_logic_op_enable_ext(
7824 _command_buffer: CommandBuffer,
7825 _logic_op_enable: Bool32,
7826 ) {
7827 panic!(concat!(
7828 "Unable to load ",
7829 stringify!(cmd_set_logic_op_enable_ext)
7830 ))
7831 }
7832 let cname =
7833 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
7834 let val = _f(cname);
7835 if val.is_null() {
7836 cmd_set_logic_op_enable_ext
7837 } else {
7838 ::core::mem::transmute(val)
7839 }
7840 },
7841 cmd_set_color_blend_enable_ext: unsafe {
7842 unsafe extern "system" fn cmd_set_color_blend_enable_ext(
7843 _command_buffer: CommandBuffer,
7844 _first_attachment: u32,
7845 _attachment_count: u32,
7846 _p_color_blend_enables: *const Bool32,
7847 ) {
7848 panic!(concat!(
7849 "Unable to load ",
7850 stringify!(cmd_set_color_blend_enable_ext)
7851 ))
7852 }
7853 let cname =
7854 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0");
7855 let val = _f(cname);
7856 if val.is_null() {
7857 cmd_set_color_blend_enable_ext
7858 } else {
7859 ::core::mem::transmute(val)
7860 }
7861 },
7862 cmd_set_color_blend_equation_ext: unsafe {
7863 unsafe extern "system" fn cmd_set_color_blend_equation_ext(
7864 _command_buffer: CommandBuffer,
7865 _first_attachment: u32,
7866 _attachment_count: u32,
7867 _p_color_blend_equations: *const ColorBlendEquationEXT,
7868 ) {
7869 panic!(concat!(
7870 "Unable to load ",
7871 stringify!(cmd_set_color_blend_equation_ext)
7872 ))
7873 }
7874 let cname =
7875 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0");
7876 let val = _f(cname);
7877 if val.is_null() {
7878 cmd_set_color_blend_equation_ext
7879 } else {
7880 ::core::mem::transmute(val)
7881 }
7882 },
7883 cmd_set_color_write_mask_ext: unsafe {
7884 unsafe extern "system" fn cmd_set_color_write_mask_ext(
7885 _command_buffer: CommandBuffer,
7886 _first_attachment: u32,
7887 _attachment_count: u32,
7888 _p_color_write_masks: *const ColorComponentFlags,
7889 ) {
7890 panic!(concat!(
7891 "Unable to load ",
7892 stringify!(cmd_set_color_write_mask_ext)
7893 ))
7894 }
7895 let cname =
7896 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
7897 let val = _f(cname);
7898 if val.is_null() {
7899 cmd_set_color_write_mask_ext
7900 } else {
7901 ::core::mem::transmute(val)
7902 }
7903 },
7904 cmd_set_rasterization_stream_ext: unsafe {
7905 unsafe extern "system" fn cmd_set_rasterization_stream_ext(
7906 _command_buffer: CommandBuffer,
7907 _rasterization_stream: u32,
7908 ) {
7909 panic!(concat!(
7910 "Unable to load ",
7911 stringify!(cmd_set_rasterization_stream_ext)
7912 ))
7913 }
7914 let cname = CStr::from_bytes_with_nul_unchecked(
7915 b"vkCmdSetRasterizationStreamEXT\0",
7916 );
7917 let val = _f(cname);
7918 if val.is_null() {
7919 cmd_set_rasterization_stream_ext
7920 } else {
7921 ::core::mem::transmute(val)
7922 }
7923 },
7924 cmd_set_conservative_rasterization_mode_ext: unsafe {
7925 unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
7926 _command_buffer: CommandBuffer,
7927 _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
7928 ) {
7929 panic!(concat!(
7930 "Unable to load ",
7931 stringify!(cmd_set_conservative_rasterization_mode_ext)
7932 ))
7933 }
7934 let cname = CStr::from_bytes_with_nul_unchecked(
7935 b"vkCmdSetConservativeRasterizationModeEXT\0",
7936 );
7937 let val = _f(cname);
7938 if val.is_null() {
7939 cmd_set_conservative_rasterization_mode_ext
7940 } else {
7941 ::core::mem::transmute(val)
7942 }
7943 },
7944 cmd_set_extra_primitive_overestimation_size_ext: unsafe {
7945 unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
7946 _command_buffer: CommandBuffer,
7947 _extra_primitive_overestimation_size: f32,
7948 ) {
7949 panic!(concat!(
7950 "Unable to load ",
7951 stringify!(cmd_set_extra_primitive_overestimation_size_ext)
7952 ))
7953 }
7954 let cname = CStr::from_bytes_with_nul_unchecked(
7955 b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
7956 );
7957 let val = _f(cname);
7958 if val.is_null() {
7959 cmd_set_extra_primitive_overestimation_size_ext
7960 } else {
7961 ::core::mem::transmute(val)
7962 }
7963 },
7964 cmd_set_depth_clip_enable_ext: unsafe {
7965 unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
7966 _command_buffer: CommandBuffer,
7967 _depth_clip_enable: Bool32,
7968 ) {
7969 panic!(concat!(
7970 "Unable to load ",
7971 stringify!(cmd_set_depth_clip_enable_ext)
7972 ))
7973 }
7974 let cname =
7975 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0");
7976 let val = _f(cname);
7977 if val.is_null() {
7978 cmd_set_depth_clip_enable_ext
7979 } else {
7980 ::core::mem::transmute(val)
7981 }
7982 },
7983 cmd_set_sample_locations_enable_ext: unsafe {
7984 unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
7985 _command_buffer: CommandBuffer,
7986 _sample_locations_enable: Bool32,
7987 ) {
7988 panic!(concat!(
7989 "Unable to load ",
7990 stringify!(cmd_set_sample_locations_enable_ext)
7991 ))
7992 }
7993 let cname = CStr::from_bytes_with_nul_unchecked(
7994 b"vkCmdSetSampleLocationsEnableEXT\0",
7995 );
7996 let val = _f(cname);
7997 if val.is_null() {
7998 cmd_set_sample_locations_enable_ext
7999 } else {
8000 ::core::mem::transmute(val)
8001 }
8002 },
8003 cmd_set_color_blend_advanced_ext: unsafe {
8004 unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
8005 _command_buffer: CommandBuffer,
8006 _first_attachment: u32,
8007 _attachment_count: u32,
8008 _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
8009 ) {
8010 panic!(concat!(
8011 "Unable to load ",
8012 stringify!(cmd_set_color_blend_advanced_ext)
8013 ))
8014 }
8015 let cname =
8016 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0");
8017 let val = _f(cname);
8018 if val.is_null() {
8019 cmd_set_color_blend_advanced_ext
8020 } else {
8021 ::core::mem::transmute(val)
8022 }
8023 },
8024 cmd_set_provoking_vertex_mode_ext: unsafe {
8025 unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
8026 _command_buffer: CommandBuffer,
8027 _provoking_vertex_mode: ProvokingVertexModeEXT,
8028 ) {
8029 panic!(concat!(
8030 "Unable to load ",
8031 stringify!(cmd_set_provoking_vertex_mode_ext)
8032 ))
8033 }
8034 let cname = CStr::from_bytes_with_nul_unchecked(
8035 b"vkCmdSetProvokingVertexModeEXT\0",
8036 );
8037 let val = _f(cname);
8038 if val.is_null() {
8039 cmd_set_provoking_vertex_mode_ext
8040 } else {
8041 ::core::mem::transmute(val)
8042 }
8043 },
8044 cmd_set_line_rasterization_mode_ext: unsafe {
8045 unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
8046 _command_buffer: CommandBuffer,
8047 _line_rasterization_mode: LineRasterizationModeEXT,
8048 ) {
8049 panic!(concat!(
8050 "Unable to load ",
8051 stringify!(cmd_set_line_rasterization_mode_ext)
8052 ))
8053 }
8054 let cname = CStr::from_bytes_with_nul_unchecked(
8055 b"vkCmdSetLineRasterizationModeEXT\0",
8056 );
8057 let val = _f(cname);
8058 if val.is_null() {
8059 cmd_set_line_rasterization_mode_ext
8060 } else {
8061 ::core::mem::transmute(val)
8062 }
8063 },
8064 cmd_set_line_stipple_enable_ext: unsafe {
8065 unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
8066 _command_buffer: CommandBuffer,
8067 _stippled_line_enable: Bool32,
8068 ) {
8069 panic!(concat!(
8070 "Unable to load ",
8071 stringify!(cmd_set_line_stipple_enable_ext)
8072 ))
8073 }
8074 let cname =
8075 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0");
8076 let val = _f(cname);
8077 if val.is_null() {
8078 cmd_set_line_stipple_enable_ext
8079 } else {
8080 ::core::mem::transmute(val)
8081 }
8082 },
8083 cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
8084 unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
8085 _command_buffer: CommandBuffer,
8086 _negative_one_to_one: Bool32,
8087 ) {
8088 panic!(concat!(
8089 "Unable to load ",
8090 stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
8091 ))
8092 }
8093 let cname = CStr::from_bytes_with_nul_unchecked(
8094 b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
8095 );
8096 let val = _f(cname);
8097 if val.is_null() {
8098 cmd_set_depth_clip_negative_one_to_one_ext
8099 } else {
8100 ::core::mem::transmute(val)
8101 }
8102 },
8103 cmd_set_viewport_w_scaling_enable_nv: unsafe {
8104 unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
8105 _command_buffer: CommandBuffer,
8106 _viewport_w_scaling_enable: Bool32,
8107 ) {
8108 panic!(concat!(
8109 "Unable to load ",
8110 stringify!(cmd_set_viewport_w_scaling_enable_nv)
8111 ))
8112 }
8113 let cname = CStr::from_bytes_with_nul_unchecked(
8114 b"vkCmdSetViewportWScalingEnableNV\0",
8115 );
8116 let val = _f(cname);
8117 if val.is_null() {
8118 cmd_set_viewport_w_scaling_enable_nv
8119 } else {
8120 ::core::mem::transmute(val)
8121 }
8122 },
8123 cmd_set_viewport_swizzle_nv: unsafe {
8124 unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
8125 _command_buffer: CommandBuffer,
8126 _first_viewport: u32,
8127 _viewport_count: u32,
8128 _p_viewport_swizzles: *const ViewportSwizzleNV,
8129 ) {
8130 panic!(concat!(
8131 "Unable to load ",
8132 stringify!(cmd_set_viewport_swizzle_nv)
8133 ))
8134 }
8135 let cname =
8136 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
8137 let val = _f(cname);
8138 if val.is_null() {
8139 cmd_set_viewport_swizzle_nv
8140 } else {
8141 ::core::mem::transmute(val)
8142 }
8143 },
8144 cmd_set_coverage_to_color_enable_nv: unsafe {
8145 unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
8146 _command_buffer: CommandBuffer,
8147 _coverage_to_color_enable: Bool32,
8148 ) {
8149 panic!(concat!(
8150 "Unable to load ",
8151 stringify!(cmd_set_coverage_to_color_enable_nv)
8152 ))
8153 }
8154 let cname = CStr::from_bytes_with_nul_unchecked(
8155 b"vkCmdSetCoverageToColorEnableNV\0",
8156 );
8157 let val = _f(cname);
8158 if val.is_null() {
8159 cmd_set_coverage_to_color_enable_nv
8160 } else {
8161 ::core::mem::transmute(val)
8162 }
8163 },
8164 cmd_set_coverage_to_color_location_nv: unsafe {
8165 unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
8166 _command_buffer: CommandBuffer,
8167 _coverage_to_color_location: u32,
8168 ) {
8169 panic!(concat!(
8170 "Unable to load ",
8171 stringify!(cmd_set_coverage_to_color_location_nv)
8172 ))
8173 }
8174 let cname = CStr::from_bytes_with_nul_unchecked(
8175 b"vkCmdSetCoverageToColorLocationNV\0",
8176 );
8177 let val = _f(cname);
8178 if val.is_null() {
8179 cmd_set_coverage_to_color_location_nv
8180 } else {
8181 ::core::mem::transmute(val)
8182 }
8183 },
8184 cmd_set_coverage_modulation_mode_nv: unsafe {
8185 unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
8186 _command_buffer: CommandBuffer,
8187 _coverage_modulation_mode: CoverageModulationModeNV,
8188 ) {
8189 panic!(concat!(
8190 "Unable to load ",
8191 stringify!(cmd_set_coverage_modulation_mode_nv)
8192 ))
8193 }
8194 let cname = CStr::from_bytes_with_nul_unchecked(
8195 b"vkCmdSetCoverageModulationModeNV\0",
8196 );
8197 let val = _f(cname);
8198 if val.is_null() {
8199 cmd_set_coverage_modulation_mode_nv
8200 } else {
8201 ::core::mem::transmute(val)
8202 }
8203 },
8204 cmd_set_coverage_modulation_table_enable_nv: unsafe {
8205 unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
8206 _command_buffer: CommandBuffer,
8207 _coverage_modulation_table_enable: Bool32,
8208 ) {
8209 panic!(concat!(
8210 "Unable to load ",
8211 stringify!(cmd_set_coverage_modulation_table_enable_nv)
8212 ))
8213 }
8214 let cname = CStr::from_bytes_with_nul_unchecked(
8215 b"vkCmdSetCoverageModulationTableEnableNV\0",
8216 );
8217 let val = _f(cname);
8218 if val.is_null() {
8219 cmd_set_coverage_modulation_table_enable_nv
8220 } else {
8221 ::core::mem::transmute(val)
8222 }
8223 },
8224 cmd_set_coverage_modulation_table_nv: unsafe {
8225 unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
8226 _command_buffer: CommandBuffer,
8227 _coverage_modulation_table_count: u32,
8228 _p_coverage_modulation_table: *const f32,
8229 ) {
8230 panic!(concat!(
8231 "Unable to load ",
8232 stringify!(cmd_set_coverage_modulation_table_nv)
8233 ))
8234 }
8235 let cname = CStr::from_bytes_with_nul_unchecked(
8236 b"vkCmdSetCoverageModulationTableNV\0",
8237 );
8238 let val = _f(cname);
8239 if val.is_null() {
8240 cmd_set_coverage_modulation_table_nv
8241 } else {
8242 ::core::mem::transmute(val)
8243 }
8244 },
8245 cmd_set_shading_rate_image_enable_nv: unsafe {
8246 unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
8247 _command_buffer: CommandBuffer,
8248 _shading_rate_image_enable: Bool32,
8249 ) {
8250 panic!(concat!(
8251 "Unable to load ",
8252 stringify!(cmd_set_shading_rate_image_enable_nv)
8253 ))
8254 }
8255 let cname = CStr::from_bytes_with_nul_unchecked(
8256 b"vkCmdSetShadingRateImageEnableNV\0",
8257 );
8258 let val = _f(cname);
8259 if val.is_null() {
8260 cmd_set_shading_rate_image_enable_nv
8261 } else {
8262 ::core::mem::transmute(val)
8263 }
8264 },
8265 cmd_set_representative_fragment_test_enable_nv: unsafe {
8266 unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
8267 _command_buffer: CommandBuffer,
8268 _representative_fragment_test_enable: Bool32,
8269 ) {
8270 panic!(concat!(
8271 "Unable to load ",
8272 stringify!(cmd_set_representative_fragment_test_enable_nv)
8273 ))
8274 }
8275 let cname = CStr::from_bytes_with_nul_unchecked(
8276 b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
8277 );
8278 let val = _f(cname);
8279 if val.is_null() {
8280 cmd_set_representative_fragment_test_enable_nv
8281 } else {
8282 ::core::mem::transmute(val)
8283 }
8284 },
8285 cmd_set_coverage_reduction_mode_nv: unsafe {
8286 unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
8287 _command_buffer: CommandBuffer,
8288 _coverage_reduction_mode: CoverageReductionModeNV,
8289 ) {
8290 panic!(concat!(
8291 "Unable to load ",
8292 stringify!(cmd_set_coverage_reduction_mode_nv)
8293 ))
8294 }
8295 let cname = CStr::from_bytes_with_nul_unchecked(
8296 b"vkCmdSetCoverageReductionModeNV\0",
8297 );
8298 let val = _f(cname);
8299 if val.is_null() {
8300 cmd_set_coverage_reduction_mode_nv
8301 } else {
8302 ::core::mem::transmute(val)
8303 }
8304 },
8305 }
8306 }
8307 }
8308 }
8309 #[doc = "VK_EXT_mutable_descriptor_type"]
8310 pub mod mutable_descriptor_type {
8311 use super::super::*;
8312 pub use {
8313 crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_NAME as NAME,
8314 crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION as SPEC_VERSION,
8315 };
8316 }
8317 #[doc = "VK_EXT_layer_settings"]
8318 pub mod layer_settings {
8319 use super::super::*;
8320 pub use {
8321 crate::vk::EXT_LAYER_SETTINGS_NAME as NAME,
8322 crate::vk::EXT_LAYER_SETTINGS_SPEC_VERSION as SPEC_VERSION,
8323 };
8324 }
8325 #[doc = "VK_EXT_pipeline_library_group_handles"]
8326 pub mod pipeline_library_group_handles {
8327 use super::super::*;
8328 pub use {
8329 crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_NAME as NAME,
8330 crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION as SPEC_VERSION,
8331 };
8332 }
8333 #[doc = "VK_EXT_dynamic_rendering_unused_attachments"]
8334 pub mod dynamic_rendering_unused_attachments {
8335 use super::super::*;
8336 pub use {
8337 crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_NAME as NAME,
8338 crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION as SPEC_VERSION,
8339 };
8340 }
8341 #[doc = "VK_EXT_attachment_feedback_loop_dynamic_state"]
8342 pub mod attachment_feedback_loop_dynamic_state {
8343 use super::super::*;
8344 pub use {
8345 crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_NAME as NAME,
8346 crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
8347 };
8348 #[doc = "VK_EXT_attachment_feedback_loop_dynamic_state device-level functions"]
8349 #[derive(Clone)]
8350 pub struct Device {
8351 pub(crate) fp: DeviceFn,
8352 pub(crate) handle: crate::vk::Device,
8353 }
8354 impl Device {
8355 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
8356 let handle = device.handle();
8357 let fp = DeviceFn::load(|name| unsafe {
8358 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
8359 });
8360 Self { handle, fp }
8361 }
8362 #[inline]
8363 pub fn fp(&self) -> &DeviceFn {
8364 &self.fp
8365 }
8366 #[inline]
8367 pub fn device(&self) -> crate::vk::Device {
8368 self.handle
8369 }
8370 }
8371 #[derive(Clone)]
8372 #[doc = "Raw VK_EXT_attachment_feedback_loop_dynamic_state device-level function pointers"]
8373 pub struct DeviceFn {
8374 pub cmd_set_attachment_feedback_loop_enable_ext:
8375 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
8376 }
8377 unsafe impl Send for DeviceFn {}
8378 unsafe impl Sync for DeviceFn {}
8379 impl DeviceFn {
8380 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8381 Self::load_erased(&mut f)
8382 }
8383 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8384 Self {
8385 cmd_set_attachment_feedback_loop_enable_ext: unsafe {
8386 unsafe extern "system" fn cmd_set_attachment_feedback_loop_enable_ext(
8387 _command_buffer: CommandBuffer,
8388 _aspect_mask: ImageAspectFlags,
8389 ) {
8390 panic!(concat!(
8391 "Unable to load ",
8392 stringify!(cmd_set_attachment_feedback_loop_enable_ext)
8393 ))
8394 }
8395 let cname = CStr::from_bytes_with_nul_unchecked(
8396 b"vkCmdSetAttachmentFeedbackLoopEnableEXT\0",
8397 );
8398 let val = _f(cname);
8399 if val.is_null() {
8400 cmd_set_attachment_feedback_loop_enable_ext
8401 } else {
8402 ::core::mem::transmute(val)
8403 }
8404 },
8405 }
8406 }
8407 }
8408 }
8409}
8410#[doc = "Extensions tagged FUCHSIA"]
8411pub mod fuchsia {
8412 #[doc = "VK_FUCHSIA_imagepipe_surface"]
8413 pub mod imagepipe_surface {
8414 use super::super::*;
8415 pub use {
8416 crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_NAME as NAME,
8417 crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION as SPEC_VERSION,
8418 };
8419 #[doc = "VK_FUCHSIA_imagepipe_surface instance-level functions"]
8420 #[derive(Clone)]
8421 pub struct Instance {
8422 pub(crate) fp: InstanceFn,
8423 pub(crate) handle: crate::vk::Instance,
8424 }
8425 impl Instance {
8426 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
8427 let handle = instance.handle();
8428 let fp = InstanceFn::load(|name| unsafe {
8429 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
8430 });
8431 Self { handle, fp }
8432 }
8433 #[inline]
8434 pub fn fp(&self) -> &InstanceFn {
8435 &self.fp
8436 }
8437 #[inline]
8438 pub fn instance(&self) -> crate::vk::Instance {
8439 self.handle
8440 }
8441 }
8442 #[derive(Clone)]
8443 #[doc = "Raw VK_FUCHSIA_imagepipe_surface instance-level function pointers"]
8444 pub struct InstanceFn {
8445 pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA,
8446 }
8447 unsafe impl Send for InstanceFn {}
8448 unsafe impl Sync for InstanceFn {}
8449 impl InstanceFn {
8450 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8451 Self::load_erased(&mut f)
8452 }
8453 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8454 Self {
8455 create_image_pipe_surface_fuchsia: unsafe {
8456 unsafe extern "system" fn create_image_pipe_surface_fuchsia(
8457 _instance: crate::vk::Instance,
8458 _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
8459 _p_allocator: *const AllocationCallbacks<'_>,
8460 _p_surface: *mut SurfaceKHR,
8461 ) -> Result {
8462 panic!(concat!(
8463 "Unable to load ",
8464 stringify!(create_image_pipe_surface_fuchsia)
8465 ))
8466 }
8467 let cname = CStr::from_bytes_with_nul_unchecked(
8468 b"vkCreateImagePipeSurfaceFUCHSIA\0",
8469 );
8470 let val = _f(cname);
8471 if val.is_null() {
8472 create_image_pipe_surface_fuchsia
8473 } else {
8474 ::core::mem::transmute(val)
8475 }
8476 },
8477 }
8478 }
8479 }
8480 }
8481 #[doc = "VK_FUCHSIA_external_memory"]
8482 pub mod external_memory {
8483 use super::super::*;
8484 pub use {
8485 crate::vk::FUCHSIA_EXTERNAL_MEMORY_NAME as NAME,
8486 crate::vk::FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
8487 };
8488 #[doc = "VK_FUCHSIA_external_memory device-level functions"]
8489 #[derive(Clone)]
8490 pub struct Device {
8491 pub(crate) fp: DeviceFn,
8492 pub(crate) handle: crate::vk::Device,
8493 }
8494 impl Device {
8495 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
8496 let handle = device.handle();
8497 let fp = DeviceFn::load(|name| unsafe {
8498 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
8499 });
8500 Self { handle, fp }
8501 }
8502 #[inline]
8503 pub fn fp(&self) -> &DeviceFn {
8504 &self.fp
8505 }
8506 #[inline]
8507 pub fn device(&self) -> crate::vk::Device {
8508 self.handle
8509 }
8510 }
8511 #[derive(Clone)]
8512 #[doc = "Raw VK_FUCHSIA_external_memory device-level function pointers"]
8513 pub struct DeviceFn {
8514 pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA,
8515 pub get_memory_zircon_handle_properties_fuchsia:
8516 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
8517 }
8518 unsafe impl Send for DeviceFn {}
8519 unsafe impl Sync for DeviceFn {}
8520 impl DeviceFn {
8521 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8522 Self::load_erased(&mut f)
8523 }
8524 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8525 Self {
8526 get_memory_zircon_handle_fuchsia: unsafe {
8527 unsafe extern "system" fn get_memory_zircon_handle_fuchsia(
8528 _device: crate::vk::Device,
8529 _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA<'_>,
8530 _p_zircon_handle: *mut zx_handle_t,
8531 ) -> Result {
8532 panic!(concat!(
8533 "Unable to load ",
8534 stringify!(get_memory_zircon_handle_fuchsia)
8535 ))
8536 }
8537 let cname = CStr::from_bytes_with_nul_unchecked(
8538 b"vkGetMemoryZirconHandleFUCHSIA\0",
8539 );
8540 let val = _f(cname);
8541 if val.is_null() {
8542 get_memory_zircon_handle_fuchsia
8543 } else {
8544 ::core::mem::transmute(val)
8545 }
8546 },
8547 get_memory_zircon_handle_properties_fuchsia: unsafe {
8548 unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia(
8549 _device: crate::vk::Device,
8550 _handle_type: ExternalMemoryHandleTypeFlags,
8551 _zircon_handle: zx_handle_t,
8552 _p_memory_zircon_handle_properties : * mut MemoryZirconHandlePropertiesFUCHSIA < '_ >,
8553 ) -> Result {
8554 panic!(concat!(
8555 "Unable to load ",
8556 stringify!(get_memory_zircon_handle_properties_fuchsia)
8557 ))
8558 }
8559 let cname = CStr::from_bytes_with_nul_unchecked(
8560 b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0",
8561 );
8562 let val = _f(cname);
8563 if val.is_null() {
8564 get_memory_zircon_handle_properties_fuchsia
8565 } else {
8566 ::core::mem::transmute(val)
8567 }
8568 },
8569 }
8570 }
8571 }
8572 }
8573 #[doc = "VK_FUCHSIA_external_semaphore"]
8574 pub mod external_semaphore {
8575 use super::super::*;
8576 pub use {
8577 crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_NAME as NAME,
8578 crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION as SPEC_VERSION,
8579 };
8580 #[doc = "VK_FUCHSIA_external_semaphore device-level functions"]
8581 #[derive(Clone)]
8582 pub struct Device {
8583 pub(crate) fp: DeviceFn,
8584 pub(crate) handle: crate::vk::Device,
8585 }
8586 impl Device {
8587 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
8588 let handle = device.handle();
8589 let fp = DeviceFn::load(|name| unsafe {
8590 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
8591 });
8592 Self { handle, fp }
8593 }
8594 #[inline]
8595 pub fn fp(&self) -> &DeviceFn {
8596 &self.fp
8597 }
8598 #[inline]
8599 pub fn device(&self) -> crate::vk::Device {
8600 self.handle
8601 }
8602 }
8603 #[derive(Clone)]
8604 #[doc = "Raw VK_FUCHSIA_external_semaphore device-level function pointers"]
8605 pub struct DeviceFn {
8606 pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA,
8607 pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA,
8608 }
8609 unsafe impl Send for DeviceFn {}
8610 unsafe impl Sync for DeviceFn {}
8611 impl DeviceFn {
8612 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8613 Self::load_erased(&mut f)
8614 }
8615 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8616 Self {
8617 import_semaphore_zircon_handle_fuchsia: unsafe {
8618 unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia(
8619 _device: crate::vk::Device,
8620 _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA < '_ >,
8621 ) -> Result {
8622 panic!(concat!(
8623 "Unable to load ",
8624 stringify!(import_semaphore_zircon_handle_fuchsia)
8625 ))
8626 }
8627 let cname = CStr::from_bytes_with_nul_unchecked(
8628 b"vkImportSemaphoreZirconHandleFUCHSIA\0",
8629 );
8630 let val = _f(cname);
8631 if val.is_null() {
8632 import_semaphore_zircon_handle_fuchsia
8633 } else {
8634 ::core::mem::transmute(val)
8635 }
8636 },
8637 get_semaphore_zircon_handle_fuchsia: unsafe {
8638 unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia(
8639 _device: crate::vk::Device,
8640 _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA<
8641 '_,
8642 >,
8643 _p_zircon_handle: *mut zx_handle_t,
8644 ) -> Result {
8645 panic!(concat!(
8646 "Unable to load ",
8647 stringify!(get_semaphore_zircon_handle_fuchsia)
8648 ))
8649 }
8650 let cname = CStr::from_bytes_with_nul_unchecked(
8651 b"vkGetSemaphoreZirconHandleFUCHSIA\0",
8652 );
8653 let val = _f(cname);
8654 if val.is_null() {
8655 get_semaphore_zircon_handle_fuchsia
8656 } else {
8657 ::core::mem::transmute(val)
8658 }
8659 },
8660 }
8661 }
8662 }
8663 }
8664 #[doc = "VK_FUCHSIA_buffer_collection"]
8665 pub mod buffer_collection {
8666 use super::super::*;
8667 pub use {
8668 crate::vk::FUCHSIA_BUFFER_COLLECTION_NAME as NAME,
8669 crate::vk::FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION as SPEC_VERSION,
8670 };
8671 #[doc = "VK_FUCHSIA_buffer_collection device-level functions"]
8672 #[derive(Clone)]
8673 pub struct Device {
8674 pub(crate) fp: DeviceFn,
8675 pub(crate) handle: crate::vk::Device,
8676 }
8677 impl Device {
8678 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
8679 let handle = device.handle();
8680 let fp = DeviceFn::load(|name| unsafe {
8681 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
8682 });
8683 Self { handle, fp }
8684 }
8685 #[inline]
8686 pub fn fp(&self) -> &DeviceFn {
8687 &self.fp
8688 }
8689 #[inline]
8690 pub fn device(&self) -> crate::vk::Device {
8691 self.handle
8692 }
8693 }
8694 #[derive(Clone)]
8695 #[doc = "Raw VK_FUCHSIA_buffer_collection device-level function pointers"]
8696 pub struct DeviceFn {
8697 pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA,
8698 pub set_buffer_collection_image_constraints_fuchsia:
8699 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
8700 pub set_buffer_collection_buffer_constraints_fuchsia:
8701 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
8702 pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA,
8703 pub get_buffer_collection_properties_fuchsia:
8704 PFN_vkGetBufferCollectionPropertiesFUCHSIA,
8705 }
8706 unsafe impl Send for DeviceFn {}
8707 unsafe impl Sync for DeviceFn {}
8708 impl DeviceFn {
8709 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8710 Self::load_erased(&mut f)
8711 }
8712 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8713 Self {
8714 create_buffer_collection_fuchsia: unsafe {
8715 unsafe extern "system" fn create_buffer_collection_fuchsia(
8716 _device: crate::vk::Device,
8717 _p_create_info: *const BufferCollectionCreateInfoFUCHSIA<'_>,
8718 _p_allocator: *const AllocationCallbacks<'_>,
8719 _p_collection: *mut BufferCollectionFUCHSIA,
8720 ) -> Result {
8721 panic!(concat!(
8722 "Unable to load ",
8723 stringify!(create_buffer_collection_fuchsia)
8724 ))
8725 }
8726 let cname = CStr::from_bytes_with_nul_unchecked(
8727 b"vkCreateBufferCollectionFUCHSIA\0",
8728 );
8729 let val = _f(cname);
8730 if val.is_null() {
8731 create_buffer_collection_fuchsia
8732 } else {
8733 ::core::mem::transmute(val)
8734 }
8735 },
8736 set_buffer_collection_image_constraints_fuchsia: unsafe {
8737 unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia(
8738 _device: crate::vk::Device,
8739 _collection: BufferCollectionFUCHSIA,
8740 _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA<'_>,
8741 ) -> Result {
8742 panic!(concat!(
8743 "Unable to load ",
8744 stringify!(set_buffer_collection_image_constraints_fuchsia)
8745 ))
8746 }
8747 let cname = CStr::from_bytes_with_nul_unchecked(
8748 b"vkSetBufferCollectionImageConstraintsFUCHSIA\0",
8749 );
8750 let val = _f(cname);
8751 if val.is_null() {
8752 set_buffer_collection_image_constraints_fuchsia
8753 } else {
8754 ::core::mem::transmute(val)
8755 }
8756 },
8757 set_buffer_collection_buffer_constraints_fuchsia: unsafe {
8758 unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
8759 _device: crate::vk::Device,
8760 _collection: BufferCollectionFUCHSIA,
8761 _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA<'_>,
8762 ) -> Result {
8763 panic!(concat!(
8764 "Unable to load ",
8765 stringify!(set_buffer_collection_buffer_constraints_fuchsia)
8766 ))
8767 }
8768 let cname = CStr::from_bytes_with_nul_unchecked(
8769 b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0",
8770 );
8771 let val = _f(cname);
8772 if val.is_null() {
8773 set_buffer_collection_buffer_constraints_fuchsia
8774 } else {
8775 ::core::mem::transmute(val)
8776 }
8777 },
8778 destroy_buffer_collection_fuchsia: unsafe {
8779 unsafe extern "system" fn destroy_buffer_collection_fuchsia(
8780 _device: crate::vk::Device,
8781 _collection: BufferCollectionFUCHSIA,
8782 _p_allocator: *const AllocationCallbacks<'_>,
8783 ) {
8784 panic!(concat!(
8785 "Unable to load ",
8786 stringify!(destroy_buffer_collection_fuchsia)
8787 ))
8788 }
8789 let cname = CStr::from_bytes_with_nul_unchecked(
8790 b"vkDestroyBufferCollectionFUCHSIA\0",
8791 );
8792 let val = _f(cname);
8793 if val.is_null() {
8794 destroy_buffer_collection_fuchsia
8795 } else {
8796 ::core::mem::transmute(val)
8797 }
8798 },
8799 get_buffer_collection_properties_fuchsia: unsafe {
8800 unsafe extern "system" fn get_buffer_collection_properties_fuchsia(
8801 _device: crate::vk::Device,
8802 _collection: BufferCollectionFUCHSIA,
8803 _p_properties: *mut BufferCollectionPropertiesFUCHSIA<'_>,
8804 ) -> Result {
8805 panic!(concat!(
8806 "Unable to load ",
8807 stringify!(get_buffer_collection_properties_fuchsia)
8808 ))
8809 }
8810 let cname = CStr::from_bytes_with_nul_unchecked(
8811 b"vkGetBufferCollectionPropertiesFUCHSIA\0",
8812 );
8813 let val = _f(cname);
8814 if val.is_null() {
8815 get_buffer_collection_properties_fuchsia
8816 } else {
8817 ::core::mem::transmute(val)
8818 }
8819 },
8820 }
8821 }
8822 }
8823 }
8824}
8825#[doc = "Extensions tagged GGP"]
8826pub mod ggp {
8827 #[doc = "VK_GGP_stream_descriptor_surface"]
8828 pub mod stream_descriptor_surface {
8829 use super::super::*;
8830 pub use {
8831 crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_NAME as NAME,
8832 crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION as SPEC_VERSION,
8833 };
8834 #[doc = "VK_GGP_stream_descriptor_surface instance-level functions"]
8835 #[derive(Clone)]
8836 pub struct Instance {
8837 pub(crate) fp: InstanceFn,
8838 pub(crate) handle: crate::vk::Instance,
8839 }
8840 impl Instance {
8841 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
8842 let handle = instance.handle();
8843 let fp = InstanceFn::load(|name| unsafe {
8844 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
8845 });
8846 Self { handle, fp }
8847 }
8848 #[inline]
8849 pub fn fp(&self) -> &InstanceFn {
8850 &self.fp
8851 }
8852 #[inline]
8853 pub fn instance(&self) -> crate::vk::Instance {
8854 self.handle
8855 }
8856 }
8857 #[derive(Clone)]
8858 #[doc = "Raw VK_GGP_stream_descriptor_surface instance-level function pointers"]
8859 pub struct InstanceFn {
8860 pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP,
8861 }
8862 unsafe impl Send for InstanceFn {}
8863 unsafe impl Sync for InstanceFn {}
8864 impl InstanceFn {
8865 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8866 Self::load_erased(&mut f)
8867 }
8868 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8869 Self {
8870 create_stream_descriptor_surface_ggp: unsafe {
8871 unsafe extern "system" fn create_stream_descriptor_surface_ggp(
8872 _instance: crate::vk::Instance,
8873 _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP<'_>,
8874 _p_allocator: *const AllocationCallbacks<'_>,
8875 _p_surface: *mut SurfaceKHR,
8876 ) -> Result {
8877 panic!(concat!(
8878 "Unable to load ",
8879 stringify!(create_stream_descriptor_surface_ggp)
8880 ))
8881 }
8882 let cname = CStr::from_bytes_with_nul_unchecked(
8883 b"vkCreateStreamDescriptorSurfaceGGP\0",
8884 );
8885 let val = _f(cname);
8886 if val.is_null() {
8887 create_stream_descriptor_surface_ggp
8888 } else {
8889 ::core::mem::transmute(val)
8890 }
8891 },
8892 }
8893 }
8894 }
8895 }
8896 #[doc = "VK_GGP_frame_token"]
8897 pub mod frame_token {
8898 use super::super::*;
8899 pub use {
8900 crate::vk::GGP_FRAME_TOKEN_NAME as NAME,
8901 crate::vk::GGP_FRAME_TOKEN_SPEC_VERSION as SPEC_VERSION,
8902 };
8903 }
8904}
8905#[doc = "Extensions tagged GOOGLE"]
8906pub mod google {
8907 #[doc = "VK_GOOGLE_display_timing"]
8908 pub mod display_timing {
8909 use super::super::*;
8910 pub use {
8911 crate::vk::GOOGLE_DISPLAY_TIMING_NAME as NAME,
8912 crate::vk::GOOGLE_DISPLAY_TIMING_SPEC_VERSION as SPEC_VERSION,
8913 };
8914 #[doc = "VK_GOOGLE_display_timing device-level functions"]
8915 #[derive(Clone)]
8916 pub struct Device {
8917 pub(crate) fp: DeviceFn,
8918 pub(crate) handle: crate::vk::Device,
8919 }
8920 impl Device {
8921 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
8922 let handle = device.handle();
8923 let fp = DeviceFn::load(|name| unsafe {
8924 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
8925 });
8926 Self { handle, fp }
8927 }
8928 #[inline]
8929 pub fn fp(&self) -> &DeviceFn {
8930 &self.fp
8931 }
8932 #[inline]
8933 pub fn device(&self) -> crate::vk::Device {
8934 self.handle
8935 }
8936 }
8937 #[derive(Clone)]
8938 #[doc = "Raw VK_GOOGLE_display_timing device-level function pointers"]
8939 pub struct DeviceFn {
8940 pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE,
8941 pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE,
8942 }
8943 unsafe impl Send for DeviceFn {}
8944 unsafe impl Sync for DeviceFn {}
8945 impl DeviceFn {
8946 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
8947 Self::load_erased(&mut f)
8948 }
8949 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
8950 Self {
8951 get_refresh_cycle_duration_google: unsafe {
8952 unsafe extern "system" fn get_refresh_cycle_duration_google(
8953 _device: crate::vk::Device,
8954 _swapchain: SwapchainKHR,
8955 _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
8956 ) -> Result {
8957 panic!(concat!(
8958 "Unable to load ",
8959 stringify!(get_refresh_cycle_duration_google)
8960 ))
8961 }
8962 let cname = CStr::from_bytes_with_nul_unchecked(
8963 b"vkGetRefreshCycleDurationGOOGLE\0",
8964 );
8965 let val = _f(cname);
8966 if val.is_null() {
8967 get_refresh_cycle_duration_google
8968 } else {
8969 ::core::mem::transmute(val)
8970 }
8971 },
8972 get_past_presentation_timing_google: unsafe {
8973 unsafe extern "system" fn get_past_presentation_timing_google(
8974 _device: crate::vk::Device,
8975 _swapchain: SwapchainKHR,
8976 _p_presentation_timing_count: *mut u32,
8977 _p_presentation_timings: *mut PastPresentationTimingGOOGLE,
8978 ) -> Result {
8979 panic!(concat!(
8980 "Unable to load ",
8981 stringify!(get_past_presentation_timing_google)
8982 ))
8983 }
8984 let cname = CStr::from_bytes_with_nul_unchecked(
8985 b"vkGetPastPresentationTimingGOOGLE\0",
8986 );
8987 let val = _f(cname);
8988 if val.is_null() {
8989 get_past_presentation_timing_google
8990 } else {
8991 ::core::mem::transmute(val)
8992 }
8993 },
8994 }
8995 }
8996 }
8997 }
8998 #[doc = "VK_GOOGLE_hlsl_functionality1"]
8999 pub mod hlsl_functionality1 {
9000 use super::super::*;
9001 pub use {
9002 crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_NAME as NAME,
9003 crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION as SPEC_VERSION,
9004 };
9005 }
9006 #[doc = "VK_GOOGLE_decorate_string"]
9007 pub mod decorate_string {
9008 use super::super::*;
9009 pub use {
9010 crate::vk::GOOGLE_DECORATE_STRING_NAME as NAME,
9011 crate::vk::GOOGLE_DECORATE_STRING_SPEC_VERSION as SPEC_VERSION,
9012 };
9013 }
9014 #[doc = "VK_GOOGLE_user_type"]
9015 pub mod user_type {
9016 use super::super::*;
9017 pub use {
9018 crate::vk::GOOGLE_USER_TYPE_NAME as NAME,
9019 crate::vk::GOOGLE_USER_TYPE_SPEC_VERSION as SPEC_VERSION,
9020 };
9021 }
9022 #[doc = "VK_GOOGLE_surfaceless_query"]
9023 pub mod surfaceless_query {
9024 use super::super::*;
9025 pub use {
9026 crate::vk::GOOGLE_SURFACELESS_QUERY_NAME as NAME,
9027 crate::vk::GOOGLE_SURFACELESS_QUERY_SPEC_VERSION as SPEC_VERSION,
9028 };
9029 }
9030}
9031#[doc = "Extensions tagged HUAWEI"]
9032pub mod huawei {
9033 #[doc = "VK_HUAWEI_subpass_shading"]
9034 pub mod subpass_shading {
9035 use super::super::*;
9036 pub use {
9037 crate::vk::HUAWEI_SUBPASS_SHADING_NAME as NAME,
9038 crate::vk::HUAWEI_SUBPASS_SHADING_SPEC_VERSION as SPEC_VERSION,
9039 };
9040 #[doc = "VK_HUAWEI_subpass_shading device-level functions"]
9041 #[derive(Clone)]
9042 pub struct Device {
9043 pub(crate) fp: DeviceFn,
9044 pub(crate) handle: crate::vk::Device,
9045 }
9046 impl Device {
9047 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
9048 let handle = device.handle();
9049 let fp = DeviceFn::load(|name| unsafe {
9050 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
9051 });
9052 Self { handle, fp }
9053 }
9054 #[inline]
9055 pub fn fp(&self) -> &DeviceFn {
9056 &self.fp
9057 }
9058 #[inline]
9059 pub fn device(&self) -> crate::vk::Device {
9060 self.handle
9061 }
9062 }
9063 #[derive(Clone)]
9064 #[doc = "Raw VK_HUAWEI_subpass_shading device-level function pointers"]
9065 pub struct DeviceFn {
9066 pub get_device_subpass_shading_max_workgroup_size_huawei:
9067 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
9068 pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI,
9069 }
9070 unsafe impl Send for DeviceFn {}
9071 unsafe impl Sync for DeviceFn {}
9072 impl DeviceFn {
9073 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9074 Self::load_erased(&mut f)
9075 }
9076 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9077 Self {
9078 get_device_subpass_shading_max_workgroup_size_huawei: unsafe {
9079 unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
9080 _device: crate::vk::Device,
9081 _renderpass: RenderPass,
9082 _p_max_workgroup_size: *mut Extent2D,
9083 ) -> Result {
9084 panic!(concat!(
9085 "Unable to load ",
9086 stringify!(get_device_subpass_shading_max_workgroup_size_huawei)
9087 ))
9088 }
9089 let cname = CStr::from_bytes_with_nul_unchecked(
9090 b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0",
9091 );
9092 let val = _f(cname);
9093 if val.is_null() {
9094 get_device_subpass_shading_max_workgroup_size_huawei
9095 } else {
9096 ::core::mem::transmute(val)
9097 }
9098 },
9099 cmd_subpass_shading_huawei: unsafe {
9100 unsafe extern "system" fn cmd_subpass_shading_huawei(
9101 _command_buffer: CommandBuffer,
9102 ) {
9103 panic!(concat!(
9104 "Unable to load ",
9105 stringify!(cmd_subpass_shading_huawei)
9106 ))
9107 }
9108 let cname =
9109 CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0");
9110 let val = _f(cname);
9111 if val.is_null() {
9112 cmd_subpass_shading_huawei
9113 } else {
9114 ::core::mem::transmute(val)
9115 }
9116 },
9117 }
9118 }
9119 }
9120 }
9121 #[doc = "VK_HUAWEI_invocation_mask"]
9122 pub mod invocation_mask {
9123 use super::super::*;
9124 pub use {
9125 crate::vk::HUAWEI_INVOCATION_MASK_NAME as NAME,
9126 crate::vk::HUAWEI_INVOCATION_MASK_SPEC_VERSION as SPEC_VERSION,
9127 };
9128 #[doc = "VK_HUAWEI_invocation_mask device-level functions"]
9129 #[derive(Clone)]
9130 pub struct Device {
9131 pub(crate) fp: DeviceFn,
9132 pub(crate) handle: crate::vk::Device,
9133 }
9134 impl Device {
9135 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
9136 let handle = device.handle();
9137 let fp = DeviceFn::load(|name| unsafe {
9138 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
9139 });
9140 Self { handle, fp }
9141 }
9142 #[inline]
9143 pub fn fp(&self) -> &DeviceFn {
9144 &self.fp
9145 }
9146 #[inline]
9147 pub fn device(&self) -> crate::vk::Device {
9148 self.handle
9149 }
9150 }
9151 #[derive(Clone)]
9152 #[doc = "Raw VK_HUAWEI_invocation_mask device-level function pointers"]
9153 pub struct DeviceFn {
9154 pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
9155 }
9156 unsafe impl Send for DeviceFn {}
9157 unsafe impl Sync for DeviceFn {}
9158 impl DeviceFn {
9159 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9160 Self::load_erased(&mut f)
9161 }
9162 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9163 Self {
9164 cmd_bind_invocation_mask_huawei: unsafe {
9165 unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
9166 _command_buffer: CommandBuffer,
9167 _image_view: ImageView,
9168 _image_layout: ImageLayout,
9169 ) {
9170 panic!(concat!(
9171 "Unable to load ",
9172 stringify!(cmd_bind_invocation_mask_huawei)
9173 ))
9174 }
9175 let cname =
9176 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindInvocationMaskHUAWEI\0");
9177 let val = _f(cname);
9178 if val.is_null() {
9179 cmd_bind_invocation_mask_huawei
9180 } else {
9181 ::core::mem::transmute(val)
9182 }
9183 },
9184 }
9185 }
9186 }
9187 }
9188 #[doc = "VK_HUAWEI_cluster_culling_shader"]
9189 pub mod cluster_culling_shader {
9190 use super::super::*;
9191 pub use {
9192 crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_NAME as NAME,
9193 crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION as SPEC_VERSION,
9194 };
9195 #[doc = "VK_HUAWEI_cluster_culling_shader device-level functions"]
9196 #[derive(Clone)]
9197 pub struct Device {
9198 pub(crate) fp: DeviceFn,
9199 pub(crate) handle: crate::vk::Device,
9200 }
9201 impl Device {
9202 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
9203 let handle = device.handle();
9204 let fp = DeviceFn::load(|name| unsafe {
9205 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
9206 });
9207 Self { handle, fp }
9208 }
9209 #[inline]
9210 pub fn fp(&self) -> &DeviceFn {
9211 &self.fp
9212 }
9213 #[inline]
9214 pub fn device(&self) -> crate::vk::Device {
9215 self.handle
9216 }
9217 }
9218 #[derive(Clone)]
9219 #[doc = "Raw VK_HUAWEI_cluster_culling_shader device-level function pointers"]
9220 pub struct DeviceFn {
9221 pub cmd_draw_cluster_huawei: PFN_vkCmdDrawClusterHUAWEI,
9222 pub cmd_draw_cluster_indirect_huawei: PFN_vkCmdDrawClusterIndirectHUAWEI,
9223 }
9224 unsafe impl Send for DeviceFn {}
9225 unsafe impl Sync for DeviceFn {}
9226 impl DeviceFn {
9227 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9228 Self::load_erased(&mut f)
9229 }
9230 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9231 Self {
9232 cmd_draw_cluster_huawei: unsafe {
9233 unsafe extern "system" fn cmd_draw_cluster_huawei(
9234 _command_buffer: CommandBuffer,
9235 _group_count_x: u32,
9236 _group_count_y: u32,
9237 _group_count_z: u32,
9238 ) {
9239 panic!(concat!(
9240 "Unable to load ",
9241 stringify!(cmd_draw_cluster_huawei)
9242 ))
9243 }
9244 let cname =
9245 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawClusterHUAWEI\0");
9246 let val = _f(cname);
9247 if val.is_null() {
9248 cmd_draw_cluster_huawei
9249 } else {
9250 ::core::mem::transmute(val)
9251 }
9252 },
9253 cmd_draw_cluster_indirect_huawei: unsafe {
9254 unsafe extern "system" fn cmd_draw_cluster_indirect_huawei(
9255 _command_buffer: CommandBuffer,
9256 _buffer: Buffer,
9257 _offset: DeviceSize,
9258 ) {
9259 panic!(concat!(
9260 "Unable to load ",
9261 stringify!(cmd_draw_cluster_indirect_huawei)
9262 ))
9263 }
9264 let cname = CStr::from_bytes_with_nul_unchecked(
9265 b"vkCmdDrawClusterIndirectHUAWEI\0",
9266 );
9267 let val = _f(cname);
9268 if val.is_null() {
9269 cmd_draw_cluster_indirect_huawei
9270 } else {
9271 ::core::mem::transmute(val)
9272 }
9273 },
9274 }
9275 }
9276 }
9277 }
9278}
9279#[doc = "Extensions tagged IMG"]
9280pub mod img {
9281 #[doc = "VK_IMG_filter_cubic"]
9282 pub mod filter_cubic {
9283 use super::super::*;
9284 pub use {
9285 crate::vk::IMG_FILTER_CUBIC_NAME as NAME,
9286 crate::vk::IMG_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION,
9287 };
9288 }
9289 #[doc = "VK_IMG_format_pvrtc"]
9290 pub mod format_pvrtc {
9291 use super::super::*;
9292 pub use {
9293 crate::vk::IMG_FORMAT_PVRTC_NAME as NAME,
9294 crate::vk::IMG_FORMAT_PVRTC_SPEC_VERSION as SPEC_VERSION,
9295 };
9296 }
9297 #[doc = "VK_IMG_relaxed_line_rasterization"]
9298 pub mod relaxed_line_rasterization {
9299 use super::super::*;
9300 pub use {
9301 crate::vk::IMG_RELAXED_LINE_RASTERIZATION_NAME as NAME,
9302 crate::vk::IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
9303 };
9304 }
9305}
9306#[doc = "Extensions tagged INTEL"]
9307pub mod intel {
9308 #[doc = "VK_INTEL_shader_integer_functions2"]
9309 pub mod shader_integer_functions2 {
9310 use super::super::*;
9311 pub use {
9312 crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_NAME as NAME,
9313 crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION as SPEC_VERSION,
9314 };
9315 }
9316 #[doc = "VK_INTEL_performance_query"]
9317 pub mod performance_query {
9318 use super::super::*;
9319 pub use {
9320 crate::vk::INTEL_PERFORMANCE_QUERY_NAME as NAME,
9321 crate::vk::INTEL_PERFORMANCE_QUERY_SPEC_VERSION as SPEC_VERSION,
9322 };
9323 #[doc = "VK_INTEL_performance_query device-level functions"]
9324 #[derive(Clone)]
9325 pub struct Device {
9326 pub(crate) fp: DeviceFn,
9327 pub(crate) handle: crate::vk::Device,
9328 }
9329 impl Device {
9330 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
9331 let handle = device.handle();
9332 let fp = DeviceFn::load(|name| unsafe {
9333 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
9334 });
9335 Self { handle, fp }
9336 }
9337 #[inline]
9338 pub fn fp(&self) -> &DeviceFn {
9339 &self.fp
9340 }
9341 #[inline]
9342 pub fn device(&self) -> crate::vk::Device {
9343 self.handle
9344 }
9345 }
9346 #[derive(Clone)]
9347 #[doc = "Raw VK_INTEL_performance_query device-level function pointers"]
9348 pub struct DeviceFn {
9349 pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL,
9350 pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL,
9351 pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL,
9352 pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerINTEL,
9353 pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL,
9354 pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfigurationINTEL,
9355 pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfigurationINTEL,
9356 pub queue_set_performance_configuration_intel:
9357 PFN_vkQueueSetPerformanceConfigurationINTEL,
9358 pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL,
9359 }
9360 unsafe impl Send for DeviceFn {}
9361 unsafe impl Sync for DeviceFn {}
9362 impl DeviceFn {
9363 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9364 Self::load_erased(&mut f)
9365 }
9366 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9367 Self {
9368 initialize_performance_api_intel: unsafe {
9369 unsafe extern "system" fn initialize_performance_api_intel(
9370 _device: crate::vk::Device,
9371 _p_initialize_info: *const InitializePerformanceApiInfoINTEL<'_>,
9372 ) -> Result {
9373 panic!(concat!(
9374 "Unable to load ",
9375 stringify!(initialize_performance_api_intel)
9376 ))
9377 }
9378 let cname = CStr::from_bytes_with_nul_unchecked(
9379 b"vkInitializePerformanceApiINTEL\0",
9380 );
9381 let val = _f(cname);
9382 if val.is_null() {
9383 initialize_performance_api_intel
9384 } else {
9385 ::core::mem::transmute(val)
9386 }
9387 },
9388 uninitialize_performance_api_intel: unsafe {
9389 unsafe extern "system" fn uninitialize_performance_api_intel(
9390 _device: crate::vk::Device,
9391 ) {
9392 panic!(concat!(
9393 "Unable to load ",
9394 stringify!(uninitialize_performance_api_intel)
9395 ))
9396 }
9397 let cname = CStr::from_bytes_with_nul_unchecked(
9398 b"vkUninitializePerformanceApiINTEL\0",
9399 );
9400 let val = _f(cname);
9401 if val.is_null() {
9402 uninitialize_performance_api_intel
9403 } else {
9404 ::core::mem::transmute(val)
9405 }
9406 },
9407 cmd_set_performance_marker_intel: unsafe {
9408 unsafe extern "system" fn cmd_set_performance_marker_intel(
9409 _command_buffer: CommandBuffer,
9410 _p_marker_info: *const PerformanceMarkerInfoINTEL<'_>,
9411 ) -> Result {
9412 panic!(concat!(
9413 "Unable to load ",
9414 stringify!(cmd_set_performance_marker_intel)
9415 ))
9416 }
9417 let cname = CStr::from_bytes_with_nul_unchecked(
9418 b"vkCmdSetPerformanceMarkerINTEL\0",
9419 );
9420 let val = _f(cname);
9421 if val.is_null() {
9422 cmd_set_performance_marker_intel
9423 } else {
9424 ::core::mem::transmute(val)
9425 }
9426 },
9427 cmd_set_performance_stream_marker_intel: unsafe {
9428 unsafe extern "system" fn cmd_set_performance_stream_marker_intel(
9429 _command_buffer: CommandBuffer,
9430 _p_marker_info: *const PerformanceStreamMarkerInfoINTEL<'_>,
9431 ) -> Result {
9432 panic!(concat!(
9433 "Unable to load ",
9434 stringify!(cmd_set_performance_stream_marker_intel)
9435 ))
9436 }
9437 let cname = CStr::from_bytes_with_nul_unchecked(
9438 b"vkCmdSetPerformanceStreamMarkerINTEL\0",
9439 );
9440 let val = _f(cname);
9441 if val.is_null() {
9442 cmd_set_performance_stream_marker_intel
9443 } else {
9444 ::core::mem::transmute(val)
9445 }
9446 },
9447 cmd_set_performance_override_intel: unsafe {
9448 unsafe extern "system" fn cmd_set_performance_override_intel(
9449 _command_buffer: CommandBuffer,
9450 _p_override_info: *const PerformanceOverrideInfoINTEL<'_>,
9451 ) -> Result {
9452 panic!(concat!(
9453 "Unable to load ",
9454 stringify!(cmd_set_performance_override_intel)
9455 ))
9456 }
9457 let cname = CStr::from_bytes_with_nul_unchecked(
9458 b"vkCmdSetPerformanceOverrideINTEL\0",
9459 );
9460 let val = _f(cname);
9461 if val.is_null() {
9462 cmd_set_performance_override_intel
9463 } else {
9464 ::core::mem::transmute(val)
9465 }
9466 },
9467 acquire_performance_configuration_intel: unsafe {
9468 unsafe extern "system" fn acquire_performance_configuration_intel(
9469 _device: crate::vk::Device,
9470 _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL<'_>,
9471 _p_configuration: *mut PerformanceConfigurationINTEL,
9472 ) -> Result {
9473 panic!(concat!(
9474 "Unable to load ",
9475 stringify!(acquire_performance_configuration_intel)
9476 ))
9477 }
9478 let cname = CStr::from_bytes_with_nul_unchecked(
9479 b"vkAcquirePerformanceConfigurationINTEL\0",
9480 );
9481 let val = _f(cname);
9482 if val.is_null() {
9483 acquire_performance_configuration_intel
9484 } else {
9485 ::core::mem::transmute(val)
9486 }
9487 },
9488 release_performance_configuration_intel: unsafe {
9489 unsafe extern "system" fn release_performance_configuration_intel(
9490 _device: crate::vk::Device,
9491 _configuration: PerformanceConfigurationINTEL,
9492 ) -> Result {
9493 panic!(concat!(
9494 "Unable to load ",
9495 stringify!(release_performance_configuration_intel)
9496 ))
9497 }
9498 let cname = CStr::from_bytes_with_nul_unchecked(
9499 b"vkReleasePerformanceConfigurationINTEL\0",
9500 );
9501 let val = _f(cname);
9502 if val.is_null() {
9503 release_performance_configuration_intel
9504 } else {
9505 ::core::mem::transmute(val)
9506 }
9507 },
9508 queue_set_performance_configuration_intel: unsafe {
9509 unsafe extern "system" fn queue_set_performance_configuration_intel(
9510 _queue: Queue,
9511 _configuration: PerformanceConfigurationINTEL,
9512 ) -> Result {
9513 panic!(concat!(
9514 "Unable to load ",
9515 stringify!(queue_set_performance_configuration_intel)
9516 ))
9517 }
9518 let cname = CStr::from_bytes_with_nul_unchecked(
9519 b"vkQueueSetPerformanceConfigurationINTEL\0",
9520 );
9521 let val = _f(cname);
9522 if val.is_null() {
9523 queue_set_performance_configuration_intel
9524 } else {
9525 ::core::mem::transmute(val)
9526 }
9527 },
9528 get_performance_parameter_intel: unsafe {
9529 unsafe extern "system" fn get_performance_parameter_intel(
9530 _device: crate::vk::Device,
9531 _parameter: PerformanceParameterTypeINTEL,
9532 _p_value: *mut PerformanceValueINTEL,
9533 ) -> Result {
9534 panic!(concat!(
9535 "Unable to load ",
9536 stringify!(get_performance_parameter_intel)
9537 ))
9538 }
9539 let cname = CStr::from_bytes_with_nul_unchecked(
9540 b"vkGetPerformanceParameterINTEL\0",
9541 );
9542 let val = _f(cname);
9543 if val.is_null() {
9544 get_performance_parameter_intel
9545 } else {
9546 ::core::mem::transmute(val)
9547 }
9548 },
9549 }
9550 }
9551 }
9552 }
9553}
9554#[doc = "Extensions tagged KHR"]
9555pub mod khr {
9556 #[doc = "VK_KHR_surface"]
9557 pub mod surface {
9558 use super::super::*;
9559 pub use {
9560 crate::vk::KHR_SURFACE_NAME as NAME,
9561 crate::vk::KHR_SURFACE_SPEC_VERSION as SPEC_VERSION,
9562 };
9563 #[doc = "VK_KHR_surface instance-level functions"]
9564 #[derive(Clone)]
9565 pub struct Instance {
9566 pub(crate) fp: InstanceFn,
9567 pub(crate) handle: crate::vk::Instance,
9568 }
9569 impl Instance {
9570 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
9571 let handle = instance.handle();
9572 let fp = InstanceFn::load(|name| unsafe {
9573 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
9574 });
9575 Self { handle, fp }
9576 }
9577 #[inline]
9578 pub fn fp(&self) -> &InstanceFn {
9579 &self.fp
9580 }
9581 #[inline]
9582 pub fn instance(&self) -> crate::vk::Instance {
9583 self.handle
9584 }
9585 }
9586 #[derive(Clone)]
9587 #[doc = "Raw VK_KHR_surface instance-level function pointers"]
9588 pub struct InstanceFn {
9589 pub destroy_surface_khr: PFN_vkDestroySurfaceKHR,
9590 pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
9591 pub get_physical_device_surface_capabilities_khr:
9592 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
9593 pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
9594 pub get_physical_device_surface_present_modes_khr:
9595 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
9596 }
9597 unsafe impl Send for InstanceFn {}
9598 unsafe impl Sync for InstanceFn {}
9599 impl InstanceFn {
9600 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9601 Self::load_erased(&mut f)
9602 }
9603 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9604 Self {
9605 destroy_surface_khr: unsafe {
9606 unsafe extern "system" fn destroy_surface_khr(
9607 _instance: crate::vk::Instance,
9608 _surface: SurfaceKHR,
9609 _p_allocator: *const AllocationCallbacks<'_>,
9610 ) {
9611 panic!(concat!("Unable to load ", stringify!(destroy_surface_khr)))
9612 }
9613 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0");
9614 let val = _f(cname);
9615 if val.is_null() {
9616 destroy_surface_khr
9617 } else {
9618 ::core::mem::transmute(val)
9619 }
9620 },
9621 get_physical_device_surface_support_khr: unsafe {
9622 unsafe extern "system" fn get_physical_device_surface_support_khr(
9623 _physical_device: PhysicalDevice,
9624 _queue_family_index: u32,
9625 _surface: SurfaceKHR,
9626 _p_supported: *mut Bool32,
9627 ) -> Result {
9628 panic!(concat!(
9629 "Unable to load ",
9630 stringify!(get_physical_device_surface_support_khr)
9631 ))
9632 }
9633 let cname = CStr::from_bytes_with_nul_unchecked(
9634 b"vkGetPhysicalDeviceSurfaceSupportKHR\0",
9635 );
9636 let val = _f(cname);
9637 if val.is_null() {
9638 get_physical_device_surface_support_khr
9639 } else {
9640 ::core::mem::transmute(val)
9641 }
9642 },
9643 get_physical_device_surface_capabilities_khr: unsafe {
9644 unsafe extern "system" fn get_physical_device_surface_capabilities_khr(
9645 _physical_device: PhysicalDevice,
9646 _surface: SurfaceKHR,
9647 _p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
9648 ) -> Result {
9649 panic!(concat!(
9650 "Unable to load ",
9651 stringify!(get_physical_device_surface_capabilities_khr)
9652 ))
9653 }
9654 let cname = CStr::from_bytes_with_nul_unchecked(
9655 b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0",
9656 );
9657 let val = _f(cname);
9658 if val.is_null() {
9659 get_physical_device_surface_capabilities_khr
9660 } else {
9661 ::core::mem::transmute(val)
9662 }
9663 },
9664 get_physical_device_surface_formats_khr: unsafe {
9665 unsafe extern "system" fn get_physical_device_surface_formats_khr(
9666 _physical_device: PhysicalDevice,
9667 _surface: SurfaceKHR,
9668 _p_surface_format_count: *mut u32,
9669 _p_surface_formats: *mut SurfaceFormatKHR,
9670 ) -> Result {
9671 panic!(concat!(
9672 "Unable to load ",
9673 stringify!(get_physical_device_surface_formats_khr)
9674 ))
9675 }
9676 let cname = CStr::from_bytes_with_nul_unchecked(
9677 b"vkGetPhysicalDeviceSurfaceFormatsKHR\0",
9678 );
9679 let val = _f(cname);
9680 if val.is_null() {
9681 get_physical_device_surface_formats_khr
9682 } else {
9683 ::core::mem::transmute(val)
9684 }
9685 },
9686 get_physical_device_surface_present_modes_khr: unsafe {
9687 unsafe extern "system" fn get_physical_device_surface_present_modes_khr(
9688 _physical_device: PhysicalDevice,
9689 _surface: SurfaceKHR,
9690 _p_present_mode_count: *mut u32,
9691 _p_present_modes: *mut PresentModeKHR,
9692 ) -> Result {
9693 panic!(concat!(
9694 "Unable to load ",
9695 stringify!(get_physical_device_surface_present_modes_khr)
9696 ))
9697 }
9698 let cname = CStr::from_bytes_with_nul_unchecked(
9699 b"vkGetPhysicalDeviceSurfacePresentModesKHR\0",
9700 );
9701 let val = _f(cname);
9702 if val.is_null() {
9703 get_physical_device_surface_present_modes_khr
9704 } else {
9705 ::core::mem::transmute(val)
9706 }
9707 },
9708 }
9709 }
9710 }
9711 }
9712 #[doc = "VK_KHR_swapchain"]
9713 pub mod swapchain {
9714 use super::super::*;
9715 pub use {
9716 crate::vk::KHR_SWAPCHAIN_NAME as NAME,
9717 crate::vk::KHR_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
9718 };
9719 #[doc = "VK_KHR_swapchain instance-level functions"]
9720 #[derive(Clone)]
9721 pub struct Instance {
9722 pub(crate) fp: InstanceFn,
9723 pub(crate) handle: crate::vk::Instance,
9724 }
9725 impl Instance {
9726 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
9727 let handle = instance.handle();
9728 let fp = InstanceFn::load(|name| unsafe {
9729 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
9730 });
9731 Self { handle, fp }
9732 }
9733 #[inline]
9734 pub fn fp(&self) -> &InstanceFn {
9735 &self.fp
9736 }
9737 #[inline]
9738 pub fn instance(&self) -> crate::vk::Instance {
9739 self.handle
9740 }
9741 }
9742 #[derive(Clone)]
9743 #[doc = "Raw VK_KHR_swapchain instance-level function pointers"]
9744 pub struct InstanceFn {
9745 pub get_physical_device_present_rectangles_khr:
9746 PFN_vkGetPhysicalDevicePresentRectanglesKHR,
9747 }
9748 unsafe impl Send for InstanceFn {}
9749 unsafe impl Sync for InstanceFn {}
9750 impl InstanceFn {
9751 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9752 Self::load_erased(&mut f)
9753 }
9754 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9755 Self {
9756 get_physical_device_present_rectangles_khr: unsafe {
9757 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
9758 _physical_device: PhysicalDevice,
9759 _surface: SurfaceKHR,
9760 _p_rect_count: *mut u32,
9761 _p_rects: *mut Rect2D,
9762 ) -> Result {
9763 panic!(concat!(
9764 "Unable to load ",
9765 stringify!(get_physical_device_present_rectangles_khr)
9766 ))
9767 }
9768 let cname = CStr::from_bytes_with_nul_unchecked(
9769 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
9770 );
9771 let val = _f(cname);
9772 if val.is_null() {
9773 get_physical_device_present_rectangles_khr
9774 } else {
9775 ::core::mem::transmute(val)
9776 }
9777 },
9778 }
9779 }
9780 }
9781 #[doc = "VK_KHR_swapchain device-level functions"]
9782 #[derive(Clone)]
9783 pub struct Device {
9784 pub(crate) fp: DeviceFn,
9785 pub(crate) handle: crate::vk::Device,
9786 }
9787 impl Device {
9788 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
9789 let handle = device.handle();
9790 let fp = DeviceFn::load(|name| unsafe {
9791 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
9792 });
9793 Self { handle, fp }
9794 }
9795 #[inline]
9796 pub fn fp(&self) -> &DeviceFn {
9797 &self.fp
9798 }
9799 #[inline]
9800 pub fn device(&self) -> crate::vk::Device {
9801 self.handle
9802 }
9803 }
9804 #[derive(Clone)]
9805 #[doc = "Raw VK_KHR_swapchain device-level function pointers"]
9806 pub struct DeviceFn {
9807 pub create_swapchain_khr: PFN_vkCreateSwapchainKHR,
9808 pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR,
9809 pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR,
9810 pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR,
9811 pub queue_present_khr: PFN_vkQueuePresentKHR,
9812 pub get_device_group_present_capabilities_khr:
9813 PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
9814 pub get_device_group_surface_present_modes_khr:
9815 PFN_vkGetDeviceGroupSurfacePresentModesKHR,
9816 pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
9817 }
9818 unsafe impl Send for DeviceFn {}
9819 unsafe impl Sync for DeviceFn {}
9820 impl DeviceFn {
9821 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
9822 Self::load_erased(&mut f)
9823 }
9824 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
9825 Self {
9826 create_swapchain_khr: unsafe {
9827 unsafe extern "system" fn create_swapchain_khr(
9828 _device: crate::vk::Device,
9829 _p_create_info: *const SwapchainCreateInfoKHR<'_>,
9830 _p_allocator: *const AllocationCallbacks<'_>,
9831 _p_swapchain: *mut SwapchainKHR,
9832 ) -> Result {
9833 panic!(concat!("Unable to load ", stringify!(create_swapchain_khr)))
9834 }
9835 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0");
9836 let val = _f(cname);
9837 if val.is_null() {
9838 create_swapchain_khr
9839 } else {
9840 ::core::mem::transmute(val)
9841 }
9842 },
9843 destroy_swapchain_khr: unsafe {
9844 unsafe extern "system" fn destroy_swapchain_khr(
9845 _device: crate::vk::Device,
9846 _swapchain: SwapchainKHR,
9847 _p_allocator: *const AllocationCallbacks<'_>,
9848 ) {
9849 panic!(concat!(
9850 "Unable to load ",
9851 stringify!(destroy_swapchain_khr)
9852 ))
9853 }
9854 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0");
9855 let val = _f(cname);
9856 if val.is_null() {
9857 destroy_swapchain_khr
9858 } else {
9859 ::core::mem::transmute(val)
9860 }
9861 },
9862 get_swapchain_images_khr: unsafe {
9863 unsafe extern "system" fn get_swapchain_images_khr(
9864 _device: crate::vk::Device,
9865 _swapchain: SwapchainKHR,
9866 _p_swapchain_image_count: *mut u32,
9867 _p_swapchain_images: *mut Image,
9868 ) -> Result {
9869 panic!(concat!(
9870 "Unable to load ",
9871 stringify!(get_swapchain_images_khr)
9872 ))
9873 }
9874 let cname =
9875 CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0");
9876 let val = _f(cname);
9877 if val.is_null() {
9878 get_swapchain_images_khr
9879 } else {
9880 ::core::mem::transmute(val)
9881 }
9882 },
9883 acquire_next_image_khr: unsafe {
9884 unsafe extern "system" fn acquire_next_image_khr(
9885 _device: crate::vk::Device,
9886 _swapchain: SwapchainKHR,
9887 _timeout: u64,
9888 _semaphore: Semaphore,
9889 _fence: Fence,
9890 _p_image_index: *mut u32,
9891 ) -> Result {
9892 panic!(concat!(
9893 "Unable to load ",
9894 stringify!(acquire_next_image_khr)
9895 ))
9896 }
9897 let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0");
9898 let val = _f(cname);
9899 if val.is_null() {
9900 acquire_next_image_khr
9901 } else {
9902 ::core::mem::transmute(val)
9903 }
9904 },
9905 queue_present_khr: unsafe {
9906 unsafe extern "system" fn queue_present_khr(
9907 _queue: Queue,
9908 _p_present_info: *const PresentInfoKHR<'_>,
9909 ) -> Result {
9910 panic!(concat!("Unable to load ", stringify!(queue_present_khr)))
9911 }
9912 let cname = CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0");
9913 let val = _f(cname);
9914 if val.is_null() {
9915 queue_present_khr
9916 } else {
9917 ::core::mem::transmute(val)
9918 }
9919 },
9920 get_device_group_present_capabilities_khr: unsafe {
9921 unsafe extern "system" fn get_device_group_present_capabilities_khr(
9922 _device: crate::vk::Device,
9923 _p_device_group_present_capabilities : * mut DeviceGroupPresentCapabilitiesKHR < '_ >,
9924 ) -> Result {
9925 panic!(concat!(
9926 "Unable to load ",
9927 stringify!(get_device_group_present_capabilities_khr)
9928 ))
9929 }
9930 let cname = CStr::from_bytes_with_nul_unchecked(
9931 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
9932 );
9933 let val = _f(cname);
9934 if val.is_null() {
9935 get_device_group_present_capabilities_khr
9936 } else {
9937 ::core::mem::transmute(val)
9938 }
9939 },
9940 get_device_group_surface_present_modes_khr: unsafe {
9941 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
9942 _device: crate::vk::Device,
9943 _surface: SurfaceKHR,
9944 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
9945 ) -> Result {
9946 panic!(concat!(
9947 "Unable to load ",
9948 stringify!(get_device_group_surface_present_modes_khr)
9949 ))
9950 }
9951 let cname = CStr::from_bytes_with_nul_unchecked(
9952 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
9953 );
9954 let val = _f(cname);
9955 if val.is_null() {
9956 get_device_group_surface_present_modes_khr
9957 } else {
9958 ::core::mem::transmute(val)
9959 }
9960 },
9961 acquire_next_image2_khr: unsafe {
9962 unsafe extern "system" fn acquire_next_image2_khr(
9963 _device: crate::vk::Device,
9964 _p_acquire_info: *const AcquireNextImageInfoKHR<'_>,
9965 _p_image_index: *mut u32,
9966 ) -> Result {
9967 panic!(concat!(
9968 "Unable to load ",
9969 stringify!(acquire_next_image2_khr)
9970 ))
9971 }
9972 let cname =
9973 CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
9974 let val = _f(cname);
9975 if val.is_null() {
9976 acquire_next_image2_khr
9977 } else {
9978 ::core::mem::transmute(val)
9979 }
9980 },
9981 }
9982 }
9983 }
9984 }
9985 #[doc = "VK_KHR_display"]
9986 pub mod display {
9987 use super::super::*;
9988 pub use {
9989 crate::vk::KHR_DISPLAY_NAME as NAME,
9990 crate::vk::KHR_DISPLAY_SPEC_VERSION as SPEC_VERSION,
9991 };
9992 #[doc = "VK_KHR_display instance-level functions"]
9993 #[derive(Clone)]
9994 pub struct Instance {
9995 pub(crate) fp: InstanceFn,
9996 pub(crate) handle: crate::vk::Instance,
9997 }
9998 impl Instance {
9999 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10000 let handle = instance.handle();
10001 let fp = InstanceFn::load(|name| unsafe {
10002 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10003 });
10004 Self { handle, fp }
10005 }
10006 #[inline]
10007 pub fn fp(&self) -> &InstanceFn {
10008 &self.fp
10009 }
10010 #[inline]
10011 pub fn instance(&self) -> crate::vk::Instance {
10012 self.handle
10013 }
10014 }
10015 #[derive(Clone)]
10016 #[doc = "Raw VK_KHR_display instance-level function pointers"]
10017 pub struct InstanceFn {
10018 pub get_physical_device_display_properties_khr:
10019 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
10020 pub get_physical_device_display_plane_properties_khr:
10021 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
10022 pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
10023 pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR,
10024 pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR,
10025 pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR,
10026 pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR,
10027 }
10028 unsafe impl Send for InstanceFn {}
10029 unsafe impl Sync for InstanceFn {}
10030 impl InstanceFn {
10031 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10032 Self::load_erased(&mut f)
10033 }
10034 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10035 Self {
10036 get_physical_device_display_properties_khr: unsafe {
10037 unsafe extern "system" fn get_physical_device_display_properties_khr(
10038 _physical_device: PhysicalDevice,
10039 _p_property_count: *mut u32,
10040 _p_properties: *mut DisplayPropertiesKHR<'_>,
10041 ) -> Result {
10042 panic!(concat!(
10043 "Unable to load ",
10044 stringify!(get_physical_device_display_properties_khr)
10045 ))
10046 }
10047 let cname = CStr::from_bytes_with_nul_unchecked(
10048 b"vkGetPhysicalDeviceDisplayPropertiesKHR\0",
10049 );
10050 let val = _f(cname);
10051 if val.is_null() {
10052 get_physical_device_display_properties_khr
10053 } else {
10054 ::core::mem::transmute(val)
10055 }
10056 },
10057 get_physical_device_display_plane_properties_khr: unsafe {
10058 unsafe extern "system" fn get_physical_device_display_plane_properties_khr(
10059 _physical_device: PhysicalDevice,
10060 _p_property_count: *mut u32,
10061 _p_properties: *mut DisplayPlanePropertiesKHR,
10062 ) -> Result {
10063 panic!(concat!(
10064 "Unable to load ",
10065 stringify!(get_physical_device_display_plane_properties_khr)
10066 ))
10067 }
10068 let cname = CStr::from_bytes_with_nul_unchecked(
10069 b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0",
10070 );
10071 let val = _f(cname);
10072 if val.is_null() {
10073 get_physical_device_display_plane_properties_khr
10074 } else {
10075 ::core::mem::transmute(val)
10076 }
10077 },
10078 get_display_plane_supported_displays_khr: unsafe {
10079 unsafe extern "system" fn get_display_plane_supported_displays_khr(
10080 _physical_device: PhysicalDevice,
10081 _plane_index: u32,
10082 _p_display_count: *mut u32,
10083 _p_displays: *mut DisplayKHR,
10084 ) -> Result {
10085 panic!(concat!(
10086 "Unable to load ",
10087 stringify!(get_display_plane_supported_displays_khr)
10088 ))
10089 }
10090 let cname = CStr::from_bytes_with_nul_unchecked(
10091 b"vkGetDisplayPlaneSupportedDisplaysKHR\0",
10092 );
10093 let val = _f(cname);
10094 if val.is_null() {
10095 get_display_plane_supported_displays_khr
10096 } else {
10097 ::core::mem::transmute(val)
10098 }
10099 },
10100 get_display_mode_properties_khr: unsafe {
10101 unsafe extern "system" fn get_display_mode_properties_khr(
10102 _physical_device: PhysicalDevice,
10103 _display: DisplayKHR,
10104 _p_property_count: *mut u32,
10105 _p_properties: *mut DisplayModePropertiesKHR,
10106 ) -> Result {
10107 panic!(concat!(
10108 "Unable to load ",
10109 stringify!(get_display_mode_properties_khr)
10110 ))
10111 }
10112 let cname =
10113 CStr::from_bytes_with_nul_unchecked(b"vkGetDisplayModePropertiesKHR\0");
10114 let val = _f(cname);
10115 if val.is_null() {
10116 get_display_mode_properties_khr
10117 } else {
10118 ::core::mem::transmute(val)
10119 }
10120 },
10121 create_display_mode_khr: unsafe {
10122 unsafe extern "system" fn create_display_mode_khr(
10123 _physical_device: PhysicalDevice,
10124 _display: DisplayKHR,
10125 _p_create_info: *const DisplayModeCreateInfoKHR<'_>,
10126 _p_allocator: *const AllocationCallbacks<'_>,
10127 _p_mode: *mut DisplayModeKHR,
10128 ) -> Result {
10129 panic!(concat!(
10130 "Unable to load ",
10131 stringify!(create_display_mode_khr)
10132 ))
10133 }
10134 let cname =
10135 CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0");
10136 let val = _f(cname);
10137 if val.is_null() {
10138 create_display_mode_khr
10139 } else {
10140 ::core::mem::transmute(val)
10141 }
10142 },
10143 get_display_plane_capabilities_khr: unsafe {
10144 unsafe extern "system" fn get_display_plane_capabilities_khr(
10145 _physical_device: PhysicalDevice,
10146 _mode: DisplayModeKHR,
10147 _plane_index: u32,
10148 _p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
10149 ) -> Result {
10150 panic!(concat!(
10151 "Unable to load ",
10152 stringify!(get_display_plane_capabilities_khr)
10153 ))
10154 }
10155 let cname = CStr::from_bytes_with_nul_unchecked(
10156 b"vkGetDisplayPlaneCapabilitiesKHR\0",
10157 );
10158 let val = _f(cname);
10159 if val.is_null() {
10160 get_display_plane_capabilities_khr
10161 } else {
10162 ::core::mem::transmute(val)
10163 }
10164 },
10165 create_display_plane_surface_khr: unsafe {
10166 unsafe extern "system" fn create_display_plane_surface_khr(
10167 _instance: crate::vk::Instance,
10168 _p_create_info: *const DisplaySurfaceCreateInfoKHR<'_>,
10169 _p_allocator: *const AllocationCallbacks<'_>,
10170 _p_surface: *mut SurfaceKHR,
10171 ) -> Result {
10172 panic!(concat!(
10173 "Unable to load ",
10174 stringify!(create_display_plane_surface_khr)
10175 ))
10176 }
10177 let cname = CStr::from_bytes_with_nul_unchecked(
10178 b"vkCreateDisplayPlaneSurfaceKHR\0",
10179 );
10180 let val = _f(cname);
10181 if val.is_null() {
10182 create_display_plane_surface_khr
10183 } else {
10184 ::core::mem::transmute(val)
10185 }
10186 },
10187 }
10188 }
10189 }
10190 }
10191 #[doc = "VK_KHR_display_swapchain"]
10192 pub mod display_swapchain {
10193 use super::super::*;
10194 pub use {
10195 crate::vk::KHR_DISPLAY_SWAPCHAIN_NAME as NAME,
10196 crate::vk::KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
10197 };
10198 #[doc = "VK_KHR_display_swapchain device-level functions"]
10199 #[derive(Clone)]
10200 pub struct Device {
10201 pub(crate) fp: DeviceFn,
10202 pub(crate) handle: crate::vk::Device,
10203 }
10204 impl Device {
10205 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
10206 let handle = device.handle();
10207 let fp = DeviceFn::load(|name| unsafe {
10208 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
10209 });
10210 Self { handle, fp }
10211 }
10212 #[inline]
10213 pub fn fp(&self) -> &DeviceFn {
10214 &self.fp
10215 }
10216 #[inline]
10217 pub fn device(&self) -> crate::vk::Device {
10218 self.handle
10219 }
10220 }
10221 #[derive(Clone)]
10222 #[doc = "Raw VK_KHR_display_swapchain device-level function pointers"]
10223 pub struct DeviceFn {
10224 pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR,
10225 }
10226 unsafe impl Send for DeviceFn {}
10227 unsafe impl Sync for DeviceFn {}
10228 impl DeviceFn {
10229 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10230 Self::load_erased(&mut f)
10231 }
10232 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10233 Self {
10234 create_shared_swapchains_khr: unsafe {
10235 unsafe extern "system" fn create_shared_swapchains_khr(
10236 _device: crate::vk::Device,
10237 _swapchain_count: u32,
10238 _p_create_infos: *const SwapchainCreateInfoKHR<'_>,
10239 _p_allocator: *const AllocationCallbacks<'_>,
10240 _p_swapchains: *mut SwapchainKHR,
10241 ) -> Result {
10242 panic!(concat!(
10243 "Unable to load ",
10244 stringify!(create_shared_swapchains_khr)
10245 ))
10246 }
10247 let cname =
10248 CStr::from_bytes_with_nul_unchecked(b"vkCreateSharedSwapchainsKHR\0");
10249 let val = _f(cname);
10250 if val.is_null() {
10251 create_shared_swapchains_khr
10252 } else {
10253 ::core::mem::transmute(val)
10254 }
10255 },
10256 }
10257 }
10258 }
10259 }
10260 #[doc = "VK_KHR_xlib_surface"]
10261 pub mod xlib_surface {
10262 use super::super::*;
10263 pub use {
10264 crate::vk::KHR_XLIB_SURFACE_NAME as NAME,
10265 crate::vk::KHR_XLIB_SURFACE_SPEC_VERSION as SPEC_VERSION,
10266 };
10267 #[doc = "VK_KHR_xlib_surface instance-level functions"]
10268 #[derive(Clone)]
10269 pub struct Instance {
10270 pub(crate) fp: InstanceFn,
10271 pub(crate) handle: crate::vk::Instance,
10272 }
10273 impl Instance {
10274 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10275 let handle = instance.handle();
10276 let fp = InstanceFn::load(|name| unsafe {
10277 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10278 });
10279 Self { handle, fp }
10280 }
10281 #[inline]
10282 pub fn fp(&self) -> &InstanceFn {
10283 &self.fp
10284 }
10285 #[inline]
10286 pub fn instance(&self) -> crate::vk::Instance {
10287 self.handle
10288 }
10289 }
10290 #[derive(Clone)]
10291 #[doc = "Raw VK_KHR_xlib_surface instance-level function pointers"]
10292 pub struct InstanceFn {
10293 pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR,
10294 pub get_physical_device_xlib_presentation_support_khr:
10295 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
10296 }
10297 unsafe impl Send for InstanceFn {}
10298 unsafe impl Sync for InstanceFn {}
10299 impl InstanceFn {
10300 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10301 Self::load_erased(&mut f)
10302 }
10303 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10304 Self {
10305 create_xlib_surface_khr: unsafe {
10306 unsafe extern "system" fn create_xlib_surface_khr(
10307 _instance: crate::vk::Instance,
10308 _p_create_info: *const XlibSurfaceCreateInfoKHR<'_>,
10309 _p_allocator: *const AllocationCallbacks<'_>,
10310 _p_surface: *mut SurfaceKHR,
10311 ) -> Result {
10312 panic!(concat!(
10313 "Unable to load ",
10314 stringify!(create_xlib_surface_khr)
10315 ))
10316 }
10317 let cname =
10318 CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0");
10319 let val = _f(cname);
10320 if val.is_null() {
10321 create_xlib_surface_khr
10322 } else {
10323 ::core::mem::transmute(val)
10324 }
10325 },
10326 get_physical_device_xlib_presentation_support_khr: unsafe {
10327 unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr(
10328 _physical_device: PhysicalDevice,
10329 _queue_family_index: u32,
10330 _dpy: *mut Display,
10331 _visual_id: VisualID,
10332 ) -> Bool32 {
10333 panic!(concat!(
10334 "Unable to load ",
10335 stringify!(get_physical_device_xlib_presentation_support_khr)
10336 ))
10337 }
10338 let cname = CStr::from_bytes_with_nul_unchecked(
10339 b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0",
10340 );
10341 let val = _f(cname);
10342 if val.is_null() {
10343 get_physical_device_xlib_presentation_support_khr
10344 } else {
10345 ::core::mem::transmute(val)
10346 }
10347 },
10348 }
10349 }
10350 }
10351 }
10352 #[doc = "VK_KHR_xcb_surface"]
10353 pub mod xcb_surface {
10354 use super::super::*;
10355 pub use {
10356 crate::vk::KHR_XCB_SURFACE_NAME as NAME,
10357 crate::vk::KHR_XCB_SURFACE_SPEC_VERSION as SPEC_VERSION,
10358 };
10359 #[doc = "VK_KHR_xcb_surface instance-level functions"]
10360 #[derive(Clone)]
10361 pub struct Instance {
10362 pub(crate) fp: InstanceFn,
10363 pub(crate) handle: crate::vk::Instance,
10364 }
10365 impl Instance {
10366 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10367 let handle = instance.handle();
10368 let fp = InstanceFn::load(|name| unsafe {
10369 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10370 });
10371 Self { handle, fp }
10372 }
10373 #[inline]
10374 pub fn fp(&self) -> &InstanceFn {
10375 &self.fp
10376 }
10377 #[inline]
10378 pub fn instance(&self) -> crate::vk::Instance {
10379 self.handle
10380 }
10381 }
10382 #[derive(Clone)]
10383 #[doc = "Raw VK_KHR_xcb_surface instance-level function pointers"]
10384 pub struct InstanceFn {
10385 pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR,
10386 pub get_physical_device_xcb_presentation_support_khr:
10387 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
10388 }
10389 unsafe impl Send for InstanceFn {}
10390 unsafe impl Sync for InstanceFn {}
10391 impl InstanceFn {
10392 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10393 Self::load_erased(&mut f)
10394 }
10395 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10396 Self {
10397 create_xcb_surface_khr: unsafe {
10398 unsafe extern "system" fn create_xcb_surface_khr(
10399 _instance: crate::vk::Instance,
10400 _p_create_info: *const XcbSurfaceCreateInfoKHR<'_>,
10401 _p_allocator: *const AllocationCallbacks<'_>,
10402 _p_surface: *mut SurfaceKHR,
10403 ) -> Result {
10404 panic!(concat!(
10405 "Unable to load ",
10406 stringify!(create_xcb_surface_khr)
10407 ))
10408 }
10409 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0");
10410 let val = _f(cname);
10411 if val.is_null() {
10412 create_xcb_surface_khr
10413 } else {
10414 ::core::mem::transmute(val)
10415 }
10416 },
10417 get_physical_device_xcb_presentation_support_khr: unsafe {
10418 unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr(
10419 _physical_device: PhysicalDevice,
10420 _queue_family_index: u32,
10421 _connection: *mut xcb_connection_t,
10422 _visual_id: xcb_visualid_t,
10423 ) -> Bool32 {
10424 panic!(concat!(
10425 "Unable to load ",
10426 stringify!(get_physical_device_xcb_presentation_support_khr)
10427 ))
10428 }
10429 let cname = CStr::from_bytes_with_nul_unchecked(
10430 b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0",
10431 );
10432 let val = _f(cname);
10433 if val.is_null() {
10434 get_physical_device_xcb_presentation_support_khr
10435 } else {
10436 ::core::mem::transmute(val)
10437 }
10438 },
10439 }
10440 }
10441 }
10442 }
10443 #[doc = "VK_KHR_wayland_surface"]
10444 pub mod wayland_surface {
10445 use super::super::*;
10446 pub use {
10447 crate::vk::KHR_WAYLAND_SURFACE_NAME as NAME,
10448 crate::vk::KHR_WAYLAND_SURFACE_SPEC_VERSION as SPEC_VERSION,
10449 };
10450 #[doc = "VK_KHR_wayland_surface instance-level functions"]
10451 #[derive(Clone)]
10452 pub struct Instance {
10453 pub(crate) fp: InstanceFn,
10454 pub(crate) handle: crate::vk::Instance,
10455 }
10456 impl Instance {
10457 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10458 let handle = instance.handle();
10459 let fp = InstanceFn::load(|name| unsafe {
10460 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10461 });
10462 Self { handle, fp }
10463 }
10464 #[inline]
10465 pub fn fp(&self) -> &InstanceFn {
10466 &self.fp
10467 }
10468 #[inline]
10469 pub fn instance(&self) -> crate::vk::Instance {
10470 self.handle
10471 }
10472 }
10473 #[derive(Clone)]
10474 #[doc = "Raw VK_KHR_wayland_surface instance-level function pointers"]
10475 pub struct InstanceFn {
10476 pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR,
10477 pub get_physical_device_wayland_presentation_support_khr:
10478 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
10479 }
10480 unsafe impl Send for InstanceFn {}
10481 unsafe impl Sync for InstanceFn {}
10482 impl InstanceFn {
10483 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10484 Self::load_erased(&mut f)
10485 }
10486 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10487 Self {
10488 create_wayland_surface_khr: unsafe {
10489 unsafe extern "system" fn create_wayland_surface_khr(
10490 _instance: crate::vk::Instance,
10491 _p_create_info: *const WaylandSurfaceCreateInfoKHR<'_>,
10492 _p_allocator: *const AllocationCallbacks<'_>,
10493 _p_surface: *mut SurfaceKHR,
10494 ) -> Result {
10495 panic!(concat!(
10496 "Unable to load ",
10497 stringify!(create_wayland_surface_khr)
10498 ))
10499 }
10500 let cname =
10501 CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0");
10502 let val = _f(cname);
10503 if val.is_null() {
10504 create_wayland_surface_khr
10505 } else {
10506 ::core::mem::transmute(val)
10507 }
10508 },
10509 get_physical_device_wayland_presentation_support_khr: unsafe {
10510 unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr(
10511 _physical_device: PhysicalDevice,
10512 _queue_family_index: u32,
10513 _display: *mut wl_display,
10514 ) -> Bool32 {
10515 panic!(concat!(
10516 "Unable to load ",
10517 stringify!(get_physical_device_wayland_presentation_support_khr)
10518 ))
10519 }
10520 let cname = CStr::from_bytes_with_nul_unchecked(
10521 b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0",
10522 );
10523 let val = _f(cname);
10524 if val.is_null() {
10525 get_physical_device_wayland_presentation_support_khr
10526 } else {
10527 ::core::mem::transmute(val)
10528 }
10529 },
10530 }
10531 }
10532 }
10533 }
10534 #[doc = "VK_KHR_android_surface"]
10535 pub mod android_surface {
10536 use super::super::*;
10537 pub use {
10538 crate::vk::KHR_ANDROID_SURFACE_NAME as NAME,
10539 crate::vk::KHR_ANDROID_SURFACE_SPEC_VERSION as SPEC_VERSION,
10540 };
10541 #[doc = "VK_KHR_android_surface instance-level functions"]
10542 #[derive(Clone)]
10543 pub struct Instance {
10544 pub(crate) fp: InstanceFn,
10545 pub(crate) handle: crate::vk::Instance,
10546 }
10547 impl Instance {
10548 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10549 let handle = instance.handle();
10550 let fp = InstanceFn::load(|name| unsafe {
10551 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10552 });
10553 Self { handle, fp }
10554 }
10555 #[inline]
10556 pub fn fp(&self) -> &InstanceFn {
10557 &self.fp
10558 }
10559 #[inline]
10560 pub fn instance(&self) -> crate::vk::Instance {
10561 self.handle
10562 }
10563 }
10564 #[derive(Clone)]
10565 #[doc = "Raw VK_KHR_android_surface instance-level function pointers"]
10566 pub struct InstanceFn {
10567 pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR,
10568 }
10569 unsafe impl Send for InstanceFn {}
10570 unsafe impl Sync for InstanceFn {}
10571 impl InstanceFn {
10572 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10573 Self::load_erased(&mut f)
10574 }
10575 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10576 Self {
10577 create_android_surface_khr: unsafe {
10578 unsafe extern "system" fn create_android_surface_khr(
10579 _instance: crate::vk::Instance,
10580 _p_create_info: *const AndroidSurfaceCreateInfoKHR<'_>,
10581 _p_allocator: *const AllocationCallbacks<'_>,
10582 _p_surface: *mut SurfaceKHR,
10583 ) -> Result {
10584 panic!(concat!(
10585 "Unable to load ",
10586 stringify!(create_android_surface_khr)
10587 ))
10588 }
10589 let cname =
10590 CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0");
10591 let val = _f(cname);
10592 if val.is_null() {
10593 create_android_surface_khr
10594 } else {
10595 ::core::mem::transmute(val)
10596 }
10597 },
10598 }
10599 }
10600 }
10601 }
10602 #[doc = "VK_KHR_win32_surface"]
10603 pub mod win32_surface {
10604 use super::super::*;
10605 pub use {
10606 crate::vk::KHR_WIN32_SURFACE_NAME as NAME,
10607 crate::vk::KHR_WIN32_SURFACE_SPEC_VERSION as SPEC_VERSION,
10608 };
10609 #[doc = "VK_KHR_win32_surface instance-level functions"]
10610 #[derive(Clone)]
10611 pub struct Instance {
10612 pub(crate) fp: InstanceFn,
10613 pub(crate) handle: crate::vk::Instance,
10614 }
10615 impl Instance {
10616 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10617 let handle = instance.handle();
10618 let fp = InstanceFn::load(|name| unsafe {
10619 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10620 });
10621 Self { handle, fp }
10622 }
10623 #[inline]
10624 pub fn fp(&self) -> &InstanceFn {
10625 &self.fp
10626 }
10627 #[inline]
10628 pub fn instance(&self) -> crate::vk::Instance {
10629 self.handle
10630 }
10631 }
10632 #[derive(Clone)]
10633 #[doc = "Raw VK_KHR_win32_surface instance-level function pointers"]
10634 pub struct InstanceFn {
10635 pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR,
10636 pub get_physical_device_win32_presentation_support_khr:
10637 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
10638 }
10639 unsafe impl Send for InstanceFn {}
10640 unsafe impl Sync for InstanceFn {}
10641 impl InstanceFn {
10642 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10643 Self::load_erased(&mut f)
10644 }
10645 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10646 Self {
10647 create_win32_surface_khr: unsafe {
10648 unsafe extern "system" fn create_win32_surface_khr(
10649 _instance: crate::vk::Instance,
10650 _p_create_info: *const Win32SurfaceCreateInfoKHR<'_>,
10651 _p_allocator: *const AllocationCallbacks<'_>,
10652 _p_surface: *mut SurfaceKHR,
10653 ) -> Result {
10654 panic!(concat!(
10655 "Unable to load ",
10656 stringify!(create_win32_surface_khr)
10657 ))
10658 }
10659 let cname =
10660 CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0");
10661 let val = _f(cname);
10662 if val.is_null() {
10663 create_win32_surface_khr
10664 } else {
10665 ::core::mem::transmute(val)
10666 }
10667 },
10668 get_physical_device_win32_presentation_support_khr: unsafe {
10669 unsafe extern "system" fn get_physical_device_win32_presentation_support_khr(
10670 _physical_device: PhysicalDevice,
10671 _queue_family_index: u32,
10672 ) -> Bool32 {
10673 panic!(concat!(
10674 "Unable to load ",
10675 stringify!(get_physical_device_win32_presentation_support_khr)
10676 ))
10677 }
10678 let cname = CStr::from_bytes_with_nul_unchecked(
10679 b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0",
10680 );
10681 let val = _f(cname);
10682 if val.is_null() {
10683 get_physical_device_win32_presentation_support_khr
10684 } else {
10685 ::core::mem::transmute(val)
10686 }
10687 },
10688 }
10689 }
10690 }
10691 }
10692 #[doc = "VK_KHR_sampler_mirror_clamp_to_edge"]
10693 pub mod sampler_mirror_clamp_to_edge {
10694 use super::super::*;
10695 pub use {
10696 crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME as NAME,
10697 crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION as SPEC_VERSION,
10698 };
10699 }
10700 #[doc = "VK_KHR_video_queue"]
10701 pub mod video_queue {
10702 use super::super::*;
10703 pub use {
10704 crate::vk::KHR_VIDEO_QUEUE_NAME as NAME,
10705 crate::vk::KHR_VIDEO_QUEUE_SPEC_VERSION as SPEC_VERSION,
10706 };
10707 #[doc = "VK_KHR_video_queue instance-level functions"]
10708 #[derive(Clone)]
10709 pub struct Instance {
10710 pub(crate) fp: InstanceFn,
10711 pub(crate) handle: crate::vk::Instance,
10712 }
10713 impl Instance {
10714 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
10715 let handle = instance.handle();
10716 let fp = InstanceFn::load(|name| unsafe {
10717 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
10718 });
10719 Self { handle, fp }
10720 }
10721 #[inline]
10722 pub fn fp(&self) -> &InstanceFn {
10723 &self.fp
10724 }
10725 #[inline]
10726 pub fn instance(&self) -> crate::vk::Instance {
10727 self.handle
10728 }
10729 }
10730 #[derive(Clone)]
10731 #[doc = "Raw VK_KHR_video_queue instance-level function pointers"]
10732 pub struct InstanceFn {
10733 pub get_physical_device_video_capabilities_khr:
10734 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
10735 pub get_physical_device_video_format_properties_khr:
10736 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
10737 }
10738 unsafe impl Send for InstanceFn {}
10739 unsafe impl Sync for InstanceFn {}
10740 impl InstanceFn {
10741 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10742 Self::load_erased(&mut f)
10743 }
10744 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10745 Self {
10746 get_physical_device_video_capabilities_khr: unsafe {
10747 unsafe extern "system" fn get_physical_device_video_capabilities_khr(
10748 _physical_device: PhysicalDevice,
10749 _p_video_profile: *const VideoProfileInfoKHR<'_>,
10750 _p_capabilities: *mut VideoCapabilitiesKHR<'_>,
10751 ) -> Result {
10752 panic!(concat!(
10753 "Unable to load ",
10754 stringify!(get_physical_device_video_capabilities_khr)
10755 ))
10756 }
10757 let cname = CStr::from_bytes_with_nul_unchecked(
10758 b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0",
10759 );
10760 let val = _f(cname);
10761 if val.is_null() {
10762 get_physical_device_video_capabilities_khr
10763 } else {
10764 ::core::mem::transmute(val)
10765 }
10766 },
10767 get_physical_device_video_format_properties_khr: unsafe {
10768 unsafe extern "system" fn get_physical_device_video_format_properties_khr(
10769 _physical_device: PhysicalDevice,
10770 _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR<'_>,
10771 _p_video_format_property_count: *mut u32,
10772 _p_video_format_properties: *mut VideoFormatPropertiesKHR<'_>,
10773 ) -> Result {
10774 panic!(concat!(
10775 "Unable to load ",
10776 stringify!(get_physical_device_video_format_properties_khr)
10777 ))
10778 }
10779 let cname = CStr::from_bytes_with_nul_unchecked(
10780 b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0",
10781 );
10782 let val = _f(cname);
10783 if val.is_null() {
10784 get_physical_device_video_format_properties_khr
10785 } else {
10786 ::core::mem::transmute(val)
10787 }
10788 },
10789 }
10790 }
10791 }
10792 #[doc = "VK_KHR_video_queue device-level functions"]
10793 #[derive(Clone)]
10794 pub struct Device {
10795 pub(crate) fp: DeviceFn,
10796 pub(crate) handle: crate::vk::Device,
10797 }
10798 impl Device {
10799 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
10800 let handle = device.handle();
10801 let fp = DeviceFn::load(|name| unsafe {
10802 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
10803 });
10804 Self { handle, fp }
10805 }
10806 #[inline]
10807 pub fn fp(&self) -> &DeviceFn {
10808 &self.fp
10809 }
10810 #[inline]
10811 pub fn device(&self) -> crate::vk::Device {
10812 self.handle
10813 }
10814 }
10815 #[derive(Clone)]
10816 #[doc = "Raw VK_KHR_video_queue device-level function pointers"]
10817 pub struct DeviceFn {
10818 pub create_video_session_khr: PFN_vkCreateVideoSessionKHR,
10819 pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR,
10820 pub get_video_session_memory_requirements_khr:
10821 PFN_vkGetVideoSessionMemoryRequirementsKHR,
10822 pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR,
10823 pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR,
10824 pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR,
10825 pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR,
10826 pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR,
10827 pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR,
10828 pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR,
10829 }
10830 unsafe impl Send for DeviceFn {}
10831 unsafe impl Sync for DeviceFn {}
10832 impl DeviceFn {
10833 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
10834 Self::load_erased(&mut f)
10835 }
10836 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
10837 Self {
10838 create_video_session_khr: unsafe {
10839 unsafe extern "system" fn create_video_session_khr(
10840 _device: crate::vk::Device,
10841 _p_create_info: *const VideoSessionCreateInfoKHR<'_>,
10842 _p_allocator: *const AllocationCallbacks<'_>,
10843 _p_video_session: *mut VideoSessionKHR,
10844 ) -> Result {
10845 panic!(concat!(
10846 "Unable to load ",
10847 stringify!(create_video_session_khr)
10848 ))
10849 }
10850 let cname =
10851 CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0");
10852 let val = _f(cname);
10853 if val.is_null() {
10854 create_video_session_khr
10855 } else {
10856 ::core::mem::transmute(val)
10857 }
10858 },
10859 destroy_video_session_khr: unsafe {
10860 unsafe extern "system" fn destroy_video_session_khr(
10861 _device: crate::vk::Device,
10862 _video_session: VideoSessionKHR,
10863 _p_allocator: *const AllocationCallbacks<'_>,
10864 ) {
10865 panic!(concat!(
10866 "Unable to load ",
10867 stringify!(destroy_video_session_khr)
10868 ))
10869 }
10870 let cname =
10871 CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0");
10872 let val = _f(cname);
10873 if val.is_null() {
10874 destroy_video_session_khr
10875 } else {
10876 ::core::mem::transmute(val)
10877 }
10878 },
10879 get_video_session_memory_requirements_khr: unsafe {
10880 unsafe extern "system" fn get_video_session_memory_requirements_khr(
10881 _device: crate::vk::Device,
10882 _video_session: VideoSessionKHR,
10883 _p_memory_requirements_count: *mut u32,
10884 _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR<'_>,
10885 ) -> Result {
10886 panic!(concat!(
10887 "Unable to load ",
10888 stringify!(get_video_session_memory_requirements_khr)
10889 ))
10890 }
10891 let cname = CStr::from_bytes_with_nul_unchecked(
10892 b"vkGetVideoSessionMemoryRequirementsKHR\0",
10893 );
10894 let val = _f(cname);
10895 if val.is_null() {
10896 get_video_session_memory_requirements_khr
10897 } else {
10898 ::core::mem::transmute(val)
10899 }
10900 },
10901 bind_video_session_memory_khr: unsafe {
10902 unsafe extern "system" fn bind_video_session_memory_khr(
10903 _device: crate::vk::Device,
10904 _video_session: VideoSessionKHR,
10905 _bind_session_memory_info_count: u32,
10906 _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR<'_>,
10907 ) -> Result {
10908 panic!(concat!(
10909 "Unable to load ",
10910 stringify!(bind_video_session_memory_khr)
10911 ))
10912 }
10913 let cname =
10914 CStr::from_bytes_with_nul_unchecked(b"vkBindVideoSessionMemoryKHR\0");
10915 let val = _f(cname);
10916 if val.is_null() {
10917 bind_video_session_memory_khr
10918 } else {
10919 ::core::mem::transmute(val)
10920 }
10921 },
10922 create_video_session_parameters_khr: unsafe {
10923 unsafe extern "system" fn create_video_session_parameters_khr(
10924 _device: crate::vk::Device,
10925 _p_create_info: *const VideoSessionParametersCreateInfoKHR<'_>,
10926 _p_allocator: *const AllocationCallbacks<'_>,
10927 _p_video_session_parameters: *mut VideoSessionParametersKHR,
10928 ) -> Result {
10929 panic!(concat!(
10930 "Unable to load ",
10931 stringify!(create_video_session_parameters_khr)
10932 ))
10933 }
10934 let cname = CStr::from_bytes_with_nul_unchecked(
10935 b"vkCreateVideoSessionParametersKHR\0",
10936 );
10937 let val = _f(cname);
10938 if val.is_null() {
10939 create_video_session_parameters_khr
10940 } else {
10941 ::core::mem::transmute(val)
10942 }
10943 },
10944 update_video_session_parameters_khr: unsafe {
10945 unsafe extern "system" fn update_video_session_parameters_khr(
10946 _device: crate::vk::Device,
10947 _video_session_parameters: VideoSessionParametersKHR,
10948 _p_update_info: *const VideoSessionParametersUpdateInfoKHR<'_>,
10949 ) -> Result {
10950 panic!(concat!(
10951 "Unable to load ",
10952 stringify!(update_video_session_parameters_khr)
10953 ))
10954 }
10955 let cname = CStr::from_bytes_with_nul_unchecked(
10956 b"vkUpdateVideoSessionParametersKHR\0",
10957 );
10958 let val = _f(cname);
10959 if val.is_null() {
10960 update_video_session_parameters_khr
10961 } else {
10962 ::core::mem::transmute(val)
10963 }
10964 },
10965 destroy_video_session_parameters_khr: unsafe {
10966 unsafe extern "system" fn destroy_video_session_parameters_khr(
10967 _device: crate::vk::Device,
10968 _video_session_parameters: VideoSessionParametersKHR,
10969 _p_allocator: *const AllocationCallbacks<'_>,
10970 ) {
10971 panic!(concat!(
10972 "Unable to load ",
10973 stringify!(destroy_video_session_parameters_khr)
10974 ))
10975 }
10976 let cname = CStr::from_bytes_with_nul_unchecked(
10977 b"vkDestroyVideoSessionParametersKHR\0",
10978 );
10979 let val = _f(cname);
10980 if val.is_null() {
10981 destroy_video_session_parameters_khr
10982 } else {
10983 ::core::mem::transmute(val)
10984 }
10985 },
10986 cmd_begin_video_coding_khr: unsafe {
10987 unsafe extern "system" fn cmd_begin_video_coding_khr(
10988 _command_buffer: CommandBuffer,
10989 _p_begin_info: *const VideoBeginCodingInfoKHR<'_>,
10990 ) {
10991 panic!(concat!(
10992 "Unable to load ",
10993 stringify!(cmd_begin_video_coding_khr)
10994 ))
10995 }
10996 let cname =
10997 CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0");
10998 let val = _f(cname);
10999 if val.is_null() {
11000 cmd_begin_video_coding_khr
11001 } else {
11002 ::core::mem::transmute(val)
11003 }
11004 },
11005 cmd_end_video_coding_khr: unsafe {
11006 unsafe extern "system" fn cmd_end_video_coding_khr(
11007 _command_buffer: CommandBuffer,
11008 _p_end_coding_info: *const VideoEndCodingInfoKHR<'_>,
11009 ) {
11010 panic!(concat!(
11011 "Unable to load ",
11012 stringify!(cmd_end_video_coding_khr)
11013 ))
11014 }
11015 let cname =
11016 CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0");
11017 let val = _f(cname);
11018 if val.is_null() {
11019 cmd_end_video_coding_khr
11020 } else {
11021 ::core::mem::transmute(val)
11022 }
11023 },
11024 cmd_control_video_coding_khr: unsafe {
11025 unsafe extern "system" fn cmd_control_video_coding_khr(
11026 _command_buffer: CommandBuffer,
11027 _p_coding_control_info: *const VideoCodingControlInfoKHR<'_>,
11028 ) {
11029 panic!(concat!(
11030 "Unable to load ",
11031 stringify!(cmd_control_video_coding_khr)
11032 ))
11033 }
11034 let cname =
11035 CStr::from_bytes_with_nul_unchecked(b"vkCmdControlVideoCodingKHR\0");
11036 let val = _f(cname);
11037 if val.is_null() {
11038 cmd_control_video_coding_khr
11039 } else {
11040 ::core::mem::transmute(val)
11041 }
11042 },
11043 }
11044 }
11045 }
11046 }
11047 #[doc = "VK_KHR_video_decode_queue"]
11048 pub mod video_decode_queue {
11049 use super::super::*;
11050 pub use {
11051 crate::vk::KHR_VIDEO_DECODE_QUEUE_NAME as NAME,
11052 crate::vk::KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION as SPEC_VERSION,
11053 };
11054 #[doc = "VK_KHR_video_decode_queue device-level functions"]
11055 #[derive(Clone)]
11056 pub struct Device {
11057 pub(crate) fp: DeviceFn,
11058 pub(crate) handle: crate::vk::Device,
11059 }
11060 impl Device {
11061 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11062 let handle = device.handle();
11063 let fp = DeviceFn::load(|name| unsafe {
11064 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
11065 });
11066 Self { handle, fp }
11067 }
11068 #[inline]
11069 pub fn fp(&self) -> &DeviceFn {
11070 &self.fp
11071 }
11072 #[inline]
11073 pub fn device(&self) -> crate::vk::Device {
11074 self.handle
11075 }
11076 }
11077 #[derive(Clone)]
11078 #[doc = "Raw VK_KHR_video_decode_queue device-level function pointers"]
11079 pub struct DeviceFn {
11080 pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR,
11081 }
11082 unsafe impl Send for DeviceFn {}
11083 unsafe impl Sync for DeviceFn {}
11084 impl DeviceFn {
11085 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11086 Self::load_erased(&mut f)
11087 }
11088 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11089 Self {
11090 cmd_decode_video_khr: unsafe {
11091 unsafe extern "system" fn cmd_decode_video_khr(
11092 _command_buffer: CommandBuffer,
11093 _p_decode_info: *const VideoDecodeInfoKHR<'_>,
11094 ) {
11095 panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr)))
11096 }
11097 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0");
11098 let val = _f(cname);
11099 if val.is_null() {
11100 cmd_decode_video_khr
11101 } else {
11102 ::core::mem::transmute(val)
11103 }
11104 },
11105 }
11106 }
11107 }
11108 }
11109 #[doc = "VK_KHR_video_encode_h264"]
11110 pub mod video_encode_h264 {
11111 use super::super::*;
11112 pub use {
11113 crate::vk::KHR_VIDEO_ENCODE_H264_NAME as NAME,
11114 crate::vk::KHR_VIDEO_ENCODE_H264_SPEC_VERSION as SPEC_VERSION,
11115 };
11116 }
11117 #[doc = "VK_KHR_video_encode_h265"]
11118 pub mod video_encode_h265 {
11119 use super::super::*;
11120 pub use {
11121 crate::vk::KHR_VIDEO_ENCODE_H265_NAME as NAME,
11122 crate::vk::KHR_VIDEO_ENCODE_H265_SPEC_VERSION as SPEC_VERSION,
11123 };
11124 }
11125 #[doc = "VK_KHR_video_decode_h264"]
11126 pub mod video_decode_h264 {
11127 use super::super::*;
11128 pub use {
11129 crate::vk::KHR_VIDEO_DECODE_H264_NAME as NAME,
11130 crate::vk::KHR_VIDEO_DECODE_H264_SPEC_VERSION as SPEC_VERSION,
11131 };
11132 }
11133 #[doc = "VK_KHR_dynamic_rendering"]
11134 pub mod dynamic_rendering {
11135 use super::super::*;
11136 pub use {
11137 crate::vk::KHR_DYNAMIC_RENDERING_NAME as NAME,
11138 crate::vk::KHR_DYNAMIC_RENDERING_SPEC_VERSION as SPEC_VERSION,
11139 };
11140 #[doc = "VK_KHR_dynamic_rendering device-level functions"]
11141 #[derive(Clone)]
11142 pub struct Device {
11143 pub(crate) fp: DeviceFn,
11144 pub(crate) handle: crate::vk::Device,
11145 }
11146 impl Device {
11147 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11148 let handle = device.handle();
11149 let fp = DeviceFn::load(|name| unsafe {
11150 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
11151 });
11152 Self { handle, fp }
11153 }
11154 #[inline]
11155 pub fn fp(&self) -> &DeviceFn {
11156 &self.fp
11157 }
11158 #[inline]
11159 pub fn device(&self) -> crate::vk::Device {
11160 self.handle
11161 }
11162 }
11163 #[derive(Clone)]
11164 #[doc = "Raw VK_KHR_dynamic_rendering device-level function pointers"]
11165 pub struct DeviceFn {
11166 pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering,
11167 pub cmd_end_rendering_khr: PFN_vkCmdEndRendering,
11168 }
11169 unsafe impl Send for DeviceFn {}
11170 unsafe impl Sync for DeviceFn {}
11171 impl DeviceFn {
11172 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11173 Self::load_erased(&mut f)
11174 }
11175 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11176 Self {
11177 cmd_begin_rendering_khr: unsafe {
11178 unsafe extern "system" fn cmd_begin_rendering_khr(
11179 _command_buffer: CommandBuffer,
11180 _p_rendering_info: *const RenderingInfo<'_>,
11181 ) {
11182 panic!(concat!(
11183 "Unable to load ",
11184 stringify!(cmd_begin_rendering_khr)
11185 ))
11186 }
11187 let cname =
11188 CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0");
11189 let val = _f(cname);
11190 if val.is_null() {
11191 cmd_begin_rendering_khr
11192 } else {
11193 ::core::mem::transmute(val)
11194 }
11195 },
11196 cmd_end_rendering_khr: unsafe {
11197 unsafe extern "system" fn cmd_end_rendering_khr(
11198 _command_buffer: CommandBuffer,
11199 ) {
11200 panic!(concat!(
11201 "Unable to load ",
11202 stringify!(cmd_end_rendering_khr)
11203 ))
11204 }
11205 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0");
11206 let val = _f(cname);
11207 if val.is_null() {
11208 cmd_end_rendering_khr
11209 } else {
11210 ::core::mem::transmute(val)
11211 }
11212 },
11213 }
11214 }
11215 }
11216 }
11217 #[doc = "VK_KHR_multiview"]
11218 pub mod multiview {
11219 use super::super::*;
11220 pub use {
11221 crate::vk::KHR_MULTIVIEW_NAME as NAME,
11222 crate::vk::KHR_MULTIVIEW_SPEC_VERSION as SPEC_VERSION,
11223 };
11224 }
11225 #[doc = "VK_KHR_get_physical_device_properties2"]
11226 pub mod get_physical_device_properties2 {
11227 use super::super::*;
11228 pub use {
11229 crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_NAME as NAME,
11230 crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
11231 };
11232 #[doc = "VK_KHR_get_physical_device_properties2 instance-level functions"]
11233 #[derive(Clone)]
11234 pub struct Instance {
11235 pub(crate) fp: InstanceFn,
11236 pub(crate) handle: crate::vk::Instance,
11237 }
11238 impl Instance {
11239 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
11240 let handle = instance.handle();
11241 let fp = InstanceFn::load(|name| unsafe {
11242 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
11243 });
11244 Self { handle, fp }
11245 }
11246 #[inline]
11247 pub fn fp(&self) -> &InstanceFn {
11248 &self.fp
11249 }
11250 #[inline]
11251 pub fn instance(&self) -> crate::vk::Instance {
11252 self.handle
11253 }
11254 }
11255 #[derive(Clone)]
11256 #[doc = "Raw VK_KHR_get_physical_device_properties2 instance-level function pointers"]
11257 pub struct InstanceFn {
11258 pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2,
11259 pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2,
11260 pub get_physical_device_format_properties2_khr:
11261 PFN_vkGetPhysicalDeviceFormatProperties2,
11262 pub get_physical_device_image_format_properties2_khr:
11263 PFN_vkGetPhysicalDeviceImageFormatProperties2,
11264 pub get_physical_device_queue_family_properties2_khr:
11265 PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
11266 pub get_physical_device_memory_properties2_khr:
11267 PFN_vkGetPhysicalDeviceMemoryProperties2,
11268 pub get_physical_device_sparse_image_format_properties2_khr:
11269 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
11270 }
11271 unsafe impl Send for InstanceFn {}
11272 unsafe impl Sync for InstanceFn {}
11273 impl InstanceFn {
11274 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11275 Self::load_erased(&mut f)
11276 }
11277 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11278 Self {
11279 get_physical_device_features2_khr: unsafe {
11280 unsafe extern "system" fn get_physical_device_features2_khr(
11281 _physical_device: PhysicalDevice,
11282 _p_features: *mut PhysicalDeviceFeatures2<'_>,
11283 ) {
11284 panic!(concat!(
11285 "Unable to load ",
11286 stringify!(get_physical_device_features2_khr)
11287 ))
11288 }
11289 let cname = CStr::from_bytes_with_nul_unchecked(
11290 b"vkGetPhysicalDeviceFeatures2KHR\0",
11291 );
11292 let val = _f(cname);
11293 if val.is_null() {
11294 get_physical_device_features2_khr
11295 } else {
11296 ::core::mem::transmute(val)
11297 }
11298 },
11299 get_physical_device_properties2_khr: unsafe {
11300 unsafe extern "system" fn get_physical_device_properties2_khr(
11301 _physical_device: PhysicalDevice,
11302 _p_properties: *mut PhysicalDeviceProperties2<'_>,
11303 ) {
11304 panic!(concat!(
11305 "Unable to load ",
11306 stringify!(get_physical_device_properties2_khr)
11307 ))
11308 }
11309 let cname = CStr::from_bytes_with_nul_unchecked(
11310 b"vkGetPhysicalDeviceProperties2KHR\0",
11311 );
11312 let val = _f(cname);
11313 if val.is_null() {
11314 get_physical_device_properties2_khr
11315 } else {
11316 ::core::mem::transmute(val)
11317 }
11318 },
11319 get_physical_device_format_properties2_khr: unsafe {
11320 unsafe extern "system" fn get_physical_device_format_properties2_khr(
11321 _physical_device: PhysicalDevice,
11322 _format: Format,
11323 _p_format_properties: *mut FormatProperties2<'_>,
11324 ) {
11325 panic!(concat!(
11326 "Unable to load ",
11327 stringify!(get_physical_device_format_properties2_khr)
11328 ))
11329 }
11330 let cname = CStr::from_bytes_with_nul_unchecked(
11331 b"vkGetPhysicalDeviceFormatProperties2KHR\0",
11332 );
11333 let val = _f(cname);
11334 if val.is_null() {
11335 get_physical_device_format_properties2_khr
11336 } else {
11337 ::core::mem::transmute(val)
11338 }
11339 },
11340 get_physical_device_image_format_properties2_khr: unsafe {
11341 unsafe extern "system" fn get_physical_device_image_format_properties2_khr(
11342 _physical_device: PhysicalDevice,
11343 _p_image_format_info: *const PhysicalDeviceImageFormatInfo2<'_>,
11344 _p_image_format_properties: *mut ImageFormatProperties2<'_>,
11345 ) -> Result {
11346 panic!(concat!(
11347 "Unable to load ",
11348 stringify!(get_physical_device_image_format_properties2_khr)
11349 ))
11350 }
11351 let cname = CStr::from_bytes_with_nul_unchecked(
11352 b"vkGetPhysicalDeviceImageFormatProperties2KHR\0",
11353 );
11354 let val = _f(cname);
11355 if val.is_null() {
11356 get_physical_device_image_format_properties2_khr
11357 } else {
11358 ::core::mem::transmute(val)
11359 }
11360 },
11361 get_physical_device_queue_family_properties2_khr: unsafe {
11362 unsafe extern "system" fn get_physical_device_queue_family_properties2_khr(
11363 _physical_device: PhysicalDevice,
11364 _p_queue_family_property_count: *mut u32,
11365 _p_queue_family_properties: *mut QueueFamilyProperties2<'_>,
11366 ) {
11367 panic!(concat!(
11368 "Unable to load ",
11369 stringify!(get_physical_device_queue_family_properties2_khr)
11370 ))
11371 }
11372 let cname = CStr::from_bytes_with_nul_unchecked(
11373 b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0",
11374 );
11375 let val = _f(cname);
11376 if val.is_null() {
11377 get_physical_device_queue_family_properties2_khr
11378 } else {
11379 ::core::mem::transmute(val)
11380 }
11381 },
11382 get_physical_device_memory_properties2_khr: unsafe {
11383 unsafe extern "system" fn get_physical_device_memory_properties2_khr(
11384 _physical_device: PhysicalDevice,
11385 _p_memory_properties: *mut PhysicalDeviceMemoryProperties2<'_>,
11386 ) {
11387 panic!(concat!(
11388 "Unable to load ",
11389 stringify!(get_physical_device_memory_properties2_khr)
11390 ))
11391 }
11392 let cname = CStr::from_bytes_with_nul_unchecked(
11393 b"vkGetPhysicalDeviceMemoryProperties2KHR\0",
11394 );
11395 let val = _f(cname);
11396 if val.is_null() {
11397 get_physical_device_memory_properties2_khr
11398 } else {
11399 ::core::mem::transmute(val)
11400 }
11401 },
11402 get_physical_device_sparse_image_format_properties2_khr: unsafe {
11403 unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr(
11404 _physical_device: PhysicalDevice,
11405 _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2<'_>,
11406 _p_property_count: *mut u32,
11407 _p_properties: *mut SparseImageFormatProperties2<'_>,
11408 ) {
11409 panic!(concat!(
11410 "Unable to load ",
11411 stringify!(get_physical_device_sparse_image_format_properties2_khr)
11412 ))
11413 }
11414 let cname = CStr::from_bytes_with_nul_unchecked(
11415 b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0",
11416 );
11417 let val = _f(cname);
11418 if val.is_null() {
11419 get_physical_device_sparse_image_format_properties2_khr
11420 } else {
11421 ::core::mem::transmute(val)
11422 }
11423 },
11424 }
11425 }
11426 }
11427 }
11428 #[doc = "VK_KHR_device_group"]
11429 pub mod device_group {
11430 use super::super::*;
11431 pub use {
11432 crate::vk::KHR_DEVICE_GROUP_NAME as NAME,
11433 crate::vk::KHR_DEVICE_GROUP_SPEC_VERSION as SPEC_VERSION,
11434 };
11435 #[doc = "VK_KHR_device_group instance-level functions"]
11436 #[derive(Clone)]
11437 pub struct Instance {
11438 pub(crate) fp: InstanceFn,
11439 pub(crate) handle: crate::vk::Instance,
11440 }
11441 impl Instance {
11442 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
11443 let handle = instance.handle();
11444 let fp = InstanceFn::load(|name| unsafe {
11445 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
11446 });
11447 Self { handle, fp }
11448 }
11449 #[inline]
11450 pub fn fp(&self) -> &InstanceFn {
11451 &self.fp
11452 }
11453 #[inline]
11454 pub fn instance(&self) -> crate::vk::Instance {
11455 self.handle
11456 }
11457 }
11458 #[derive(Clone)]
11459 #[doc = "Raw VK_KHR_device_group instance-level function pointers"]
11460 pub struct InstanceFn {
11461 pub get_physical_device_present_rectangles_khr:
11462 PFN_vkGetPhysicalDevicePresentRectanglesKHR,
11463 }
11464 unsafe impl Send for InstanceFn {}
11465 unsafe impl Sync for InstanceFn {}
11466 impl InstanceFn {
11467 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11468 Self::load_erased(&mut f)
11469 }
11470 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11471 Self {
11472 get_physical_device_present_rectangles_khr: unsafe {
11473 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
11474 _physical_device: PhysicalDevice,
11475 _surface: SurfaceKHR,
11476 _p_rect_count: *mut u32,
11477 _p_rects: *mut Rect2D,
11478 ) -> Result {
11479 panic!(concat!(
11480 "Unable to load ",
11481 stringify!(get_physical_device_present_rectangles_khr)
11482 ))
11483 }
11484 let cname = CStr::from_bytes_with_nul_unchecked(
11485 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
11486 );
11487 let val = _f(cname);
11488 if val.is_null() {
11489 get_physical_device_present_rectangles_khr
11490 } else {
11491 ::core::mem::transmute(val)
11492 }
11493 },
11494 }
11495 }
11496 }
11497 #[doc = "VK_KHR_device_group device-level functions"]
11498 #[derive(Clone)]
11499 pub struct Device {
11500 pub(crate) fp: DeviceFn,
11501 pub(crate) handle: crate::vk::Device,
11502 }
11503 impl Device {
11504 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11505 let handle = device.handle();
11506 let fp = DeviceFn::load(|name| unsafe {
11507 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
11508 });
11509 Self { handle, fp }
11510 }
11511 #[inline]
11512 pub fn fp(&self) -> &DeviceFn {
11513 &self.fp
11514 }
11515 #[inline]
11516 pub fn device(&self) -> crate::vk::Device {
11517 self.handle
11518 }
11519 }
11520 #[derive(Clone)]
11521 #[doc = "Raw VK_KHR_device_group device-level function pointers"]
11522 pub struct DeviceFn {
11523 pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatures,
11524 pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask,
11525 pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase,
11526 pub get_device_group_present_capabilities_khr:
11527 PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
11528 pub get_device_group_surface_present_modes_khr:
11529 PFN_vkGetDeviceGroupSurfacePresentModesKHR,
11530 pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
11531 }
11532 unsafe impl Send for DeviceFn {}
11533 unsafe impl Sync for DeviceFn {}
11534 impl DeviceFn {
11535 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11536 Self::load_erased(&mut f)
11537 }
11538 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11539 Self {
11540 get_device_group_peer_memory_features_khr: unsafe {
11541 unsafe extern "system" fn get_device_group_peer_memory_features_khr(
11542 _device: crate::vk::Device,
11543 _heap_index: u32,
11544 _local_device_index: u32,
11545 _remote_device_index: u32,
11546 _p_peer_memory_features: *mut PeerMemoryFeatureFlags,
11547 ) {
11548 panic!(concat!(
11549 "Unable to load ",
11550 stringify!(get_device_group_peer_memory_features_khr)
11551 ))
11552 }
11553 let cname = CStr::from_bytes_with_nul_unchecked(
11554 b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0",
11555 );
11556 let val = _f(cname);
11557 if val.is_null() {
11558 get_device_group_peer_memory_features_khr
11559 } else {
11560 ::core::mem::transmute(val)
11561 }
11562 },
11563 cmd_set_device_mask_khr: unsafe {
11564 unsafe extern "system" fn cmd_set_device_mask_khr(
11565 _command_buffer: CommandBuffer,
11566 _device_mask: u32,
11567 ) {
11568 panic!(concat!(
11569 "Unable to load ",
11570 stringify!(cmd_set_device_mask_khr)
11571 ))
11572 }
11573 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMaskKHR\0");
11574 let val = _f(cname);
11575 if val.is_null() {
11576 cmd_set_device_mask_khr
11577 } else {
11578 ::core::mem::transmute(val)
11579 }
11580 },
11581 cmd_dispatch_base_khr: unsafe {
11582 unsafe extern "system" fn cmd_dispatch_base_khr(
11583 _command_buffer: CommandBuffer,
11584 _base_group_x: u32,
11585 _base_group_y: u32,
11586 _base_group_z: u32,
11587 _group_count_x: u32,
11588 _group_count_y: u32,
11589 _group_count_z: u32,
11590 ) {
11591 panic!(concat!(
11592 "Unable to load ",
11593 stringify!(cmd_dispatch_base_khr)
11594 ))
11595 }
11596 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBaseKHR\0");
11597 let val = _f(cname);
11598 if val.is_null() {
11599 cmd_dispatch_base_khr
11600 } else {
11601 ::core::mem::transmute(val)
11602 }
11603 },
11604 get_device_group_present_capabilities_khr: unsafe {
11605 unsafe extern "system" fn get_device_group_present_capabilities_khr(
11606 _device: crate::vk::Device,
11607 _p_device_group_present_capabilities : * mut DeviceGroupPresentCapabilitiesKHR < '_ >,
11608 ) -> Result {
11609 panic!(concat!(
11610 "Unable to load ",
11611 stringify!(get_device_group_present_capabilities_khr)
11612 ))
11613 }
11614 let cname = CStr::from_bytes_with_nul_unchecked(
11615 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
11616 );
11617 let val = _f(cname);
11618 if val.is_null() {
11619 get_device_group_present_capabilities_khr
11620 } else {
11621 ::core::mem::transmute(val)
11622 }
11623 },
11624 get_device_group_surface_present_modes_khr: unsafe {
11625 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
11626 _device: crate::vk::Device,
11627 _surface: SurfaceKHR,
11628 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
11629 ) -> Result {
11630 panic!(concat!(
11631 "Unable to load ",
11632 stringify!(get_device_group_surface_present_modes_khr)
11633 ))
11634 }
11635 let cname = CStr::from_bytes_with_nul_unchecked(
11636 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
11637 );
11638 let val = _f(cname);
11639 if val.is_null() {
11640 get_device_group_surface_present_modes_khr
11641 } else {
11642 ::core::mem::transmute(val)
11643 }
11644 },
11645 acquire_next_image2_khr: unsafe {
11646 unsafe extern "system" fn acquire_next_image2_khr(
11647 _device: crate::vk::Device,
11648 _p_acquire_info: *const AcquireNextImageInfoKHR<'_>,
11649 _p_image_index: *mut u32,
11650 ) -> Result {
11651 panic!(concat!(
11652 "Unable to load ",
11653 stringify!(acquire_next_image2_khr)
11654 ))
11655 }
11656 let cname =
11657 CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
11658 let val = _f(cname);
11659 if val.is_null() {
11660 acquire_next_image2_khr
11661 } else {
11662 ::core::mem::transmute(val)
11663 }
11664 },
11665 }
11666 }
11667 }
11668 }
11669 #[doc = "VK_KHR_shader_draw_parameters"]
11670 pub mod shader_draw_parameters {
11671 use super::super::*;
11672 pub use {
11673 crate::vk::KHR_SHADER_DRAW_PARAMETERS_NAME as NAME,
11674 crate::vk::KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION as SPEC_VERSION,
11675 };
11676 }
11677 #[doc = "VK_KHR_maintenance1"]
11678 pub mod maintenance1 {
11679 use super::super::*;
11680 pub use {
11681 crate::vk::KHR_MAINTENANCE1_NAME as NAME,
11682 crate::vk::KHR_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
11683 };
11684 #[doc = "VK_KHR_maintenance1 device-level functions"]
11685 #[derive(Clone)]
11686 pub struct Device {
11687 pub(crate) fp: DeviceFn,
11688 pub(crate) handle: crate::vk::Device,
11689 }
11690 impl Device {
11691 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11692 let handle = device.handle();
11693 let fp = DeviceFn::load(|name| unsafe {
11694 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
11695 });
11696 Self { handle, fp }
11697 }
11698 #[inline]
11699 pub fn fp(&self) -> &DeviceFn {
11700 &self.fp
11701 }
11702 #[inline]
11703 pub fn device(&self) -> crate::vk::Device {
11704 self.handle
11705 }
11706 }
11707 #[derive(Clone)]
11708 #[doc = "Raw VK_KHR_maintenance1 device-level function pointers"]
11709 pub struct DeviceFn {
11710 pub trim_command_pool_khr: PFN_vkTrimCommandPool,
11711 }
11712 unsafe impl Send for DeviceFn {}
11713 unsafe impl Sync for DeviceFn {}
11714 impl DeviceFn {
11715 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11716 Self::load_erased(&mut f)
11717 }
11718 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11719 Self {
11720 trim_command_pool_khr: unsafe {
11721 unsafe extern "system" fn trim_command_pool_khr(
11722 _device: crate::vk::Device,
11723 _command_pool: CommandPool,
11724 _flags: CommandPoolTrimFlags,
11725 ) {
11726 panic!(concat!(
11727 "Unable to load ",
11728 stringify!(trim_command_pool_khr)
11729 ))
11730 }
11731 let cname = CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPoolKHR\0");
11732 let val = _f(cname);
11733 if val.is_null() {
11734 trim_command_pool_khr
11735 } else {
11736 ::core::mem::transmute(val)
11737 }
11738 },
11739 }
11740 }
11741 }
11742 }
11743 #[doc = "VK_KHR_device_group_creation"]
11744 pub mod device_group_creation {
11745 use super::super::*;
11746 pub use {
11747 crate::vk::KHR_DEVICE_GROUP_CREATION_NAME as NAME,
11748 crate::vk::KHR_DEVICE_GROUP_CREATION_SPEC_VERSION as SPEC_VERSION,
11749 };
11750 #[doc = "VK_KHR_device_group_creation instance-level functions"]
11751 #[derive(Clone)]
11752 pub struct Instance {
11753 pub(crate) fp: InstanceFn,
11754 pub(crate) handle: crate::vk::Instance,
11755 }
11756 impl Instance {
11757 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
11758 let handle = instance.handle();
11759 let fp = InstanceFn::load(|name| unsafe {
11760 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
11761 });
11762 Self { handle, fp }
11763 }
11764 #[inline]
11765 pub fn fp(&self) -> &InstanceFn {
11766 &self.fp
11767 }
11768 #[inline]
11769 pub fn instance(&self) -> crate::vk::Instance {
11770 self.handle
11771 }
11772 }
11773 #[derive(Clone)]
11774 #[doc = "Raw VK_KHR_device_group_creation instance-level function pointers"]
11775 pub struct InstanceFn {
11776 pub enumerate_physical_device_groups_khr: PFN_vkEnumeratePhysicalDeviceGroups,
11777 }
11778 unsafe impl Send for InstanceFn {}
11779 unsafe impl Sync for InstanceFn {}
11780 impl InstanceFn {
11781 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11782 Self::load_erased(&mut f)
11783 }
11784 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11785 Self {
11786 enumerate_physical_device_groups_khr: unsafe {
11787 unsafe extern "system" fn enumerate_physical_device_groups_khr(
11788 _instance: crate::vk::Instance,
11789 _p_physical_device_group_count: *mut u32,
11790 _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties<
11791 '_,
11792 >,
11793 ) -> Result {
11794 panic!(concat!(
11795 "Unable to load ",
11796 stringify!(enumerate_physical_device_groups_khr)
11797 ))
11798 }
11799 let cname = CStr::from_bytes_with_nul_unchecked(
11800 b"vkEnumeratePhysicalDeviceGroupsKHR\0",
11801 );
11802 let val = _f(cname);
11803 if val.is_null() {
11804 enumerate_physical_device_groups_khr
11805 } else {
11806 ::core::mem::transmute(val)
11807 }
11808 },
11809 }
11810 }
11811 }
11812 }
11813 #[doc = "VK_KHR_external_memory_capabilities"]
11814 pub mod external_memory_capabilities {
11815 use super::super::*;
11816 pub use {
11817 crate::vk::KHR_EXTERNAL_MEMORY_CAPABILITIES_NAME as NAME,
11818 crate::vk::KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION as SPEC_VERSION,
11819 };
11820 #[doc = "VK_KHR_external_memory_capabilities instance-level functions"]
11821 #[derive(Clone)]
11822 pub struct Instance {
11823 pub(crate) fp: InstanceFn,
11824 pub(crate) handle: crate::vk::Instance,
11825 }
11826 impl Instance {
11827 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
11828 let handle = instance.handle();
11829 let fp = InstanceFn::load(|name| unsafe {
11830 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
11831 });
11832 Self { handle, fp }
11833 }
11834 #[inline]
11835 pub fn fp(&self) -> &InstanceFn {
11836 &self.fp
11837 }
11838 #[inline]
11839 pub fn instance(&self) -> crate::vk::Instance {
11840 self.handle
11841 }
11842 }
11843 #[derive(Clone)]
11844 #[doc = "Raw VK_KHR_external_memory_capabilities instance-level function pointers"]
11845 pub struct InstanceFn {
11846 pub get_physical_device_external_buffer_properties_khr:
11847 PFN_vkGetPhysicalDeviceExternalBufferProperties,
11848 }
11849 unsafe impl Send for InstanceFn {}
11850 unsafe impl Sync for InstanceFn {}
11851 impl InstanceFn {
11852 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11853 Self::load_erased(&mut f)
11854 }
11855 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11856 Self {
11857 get_physical_device_external_buffer_properties_khr: unsafe {
11858 unsafe extern "system" fn get_physical_device_external_buffer_properties_khr(
11859 _physical_device: PhysicalDevice,
11860 _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo<'_>,
11861 _p_external_buffer_properties: *mut ExternalBufferProperties<'_>,
11862 ) {
11863 panic!(concat!(
11864 "Unable to load ",
11865 stringify!(get_physical_device_external_buffer_properties_khr)
11866 ))
11867 }
11868 let cname = CStr::from_bytes_with_nul_unchecked(
11869 b"vkGetPhysicalDeviceExternalBufferPropertiesKHR\0",
11870 );
11871 let val = _f(cname);
11872 if val.is_null() {
11873 get_physical_device_external_buffer_properties_khr
11874 } else {
11875 ::core::mem::transmute(val)
11876 }
11877 },
11878 }
11879 }
11880 }
11881 }
11882 #[doc = "VK_KHR_external_memory"]
11883 pub mod external_memory {
11884 use super::super::*;
11885 pub use {
11886 crate::vk::KHR_EXTERNAL_MEMORY_NAME as NAME,
11887 crate::vk::KHR_EXTERNAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
11888 };
11889 }
11890 #[doc = "VK_KHR_external_memory_win32"]
11891 pub mod external_memory_win32 {
11892 use super::super::*;
11893 pub use {
11894 crate::vk::KHR_EXTERNAL_MEMORY_WIN32_NAME as NAME,
11895 crate::vk::KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION as SPEC_VERSION,
11896 };
11897 #[doc = "VK_KHR_external_memory_win32 device-level functions"]
11898 #[derive(Clone)]
11899 pub struct Device {
11900 pub(crate) fp: DeviceFn,
11901 pub(crate) handle: crate::vk::Device,
11902 }
11903 impl Device {
11904 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11905 let handle = device.handle();
11906 let fp = DeviceFn::load(|name| unsafe {
11907 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
11908 });
11909 Self { handle, fp }
11910 }
11911 #[inline]
11912 pub fn fp(&self) -> &DeviceFn {
11913 &self.fp
11914 }
11915 #[inline]
11916 pub fn device(&self) -> crate::vk::Device {
11917 self.handle
11918 }
11919 }
11920 #[derive(Clone)]
11921 #[doc = "Raw VK_KHR_external_memory_win32 device-level function pointers"]
11922 pub struct DeviceFn {
11923 pub get_memory_win32_handle_khr: PFN_vkGetMemoryWin32HandleKHR,
11924 pub get_memory_win32_handle_properties_khr: PFN_vkGetMemoryWin32HandlePropertiesKHR,
11925 }
11926 unsafe impl Send for DeviceFn {}
11927 unsafe impl Sync for DeviceFn {}
11928 impl DeviceFn {
11929 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
11930 Self::load_erased(&mut f)
11931 }
11932 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
11933 Self {
11934 get_memory_win32_handle_khr: unsafe {
11935 unsafe extern "system" fn get_memory_win32_handle_khr(
11936 _device: crate::vk::Device,
11937 _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR<'_>,
11938 _p_handle: *mut HANDLE,
11939 ) -> Result {
11940 panic!(concat!(
11941 "Unable to load ",
11942 stringify!(get_memory_win32_handle_khr)
11943 ))
11944 }
11945 let cname =
11946 CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleKHR\0");
11947 let val = _f(cname);
11948 if val.is_null() {
11949 get_memory_win32_handle_khr
11950 } else {
11951 ::core::mem::transmute(val)
11952 }
11953 },
11954 get_memory_win32_handle_properties_khr: unsafe {
11955 unsafe extern "system" fn get_memory_win32_handle_properties_khr(
11956 _device: crate::vk::Device,
11957 _handle_type: ExternalMemoryHandleTypeFlags,
11958 _handle: HANDLE,
11959 _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR<
11960 '_,
11961 >,
11962 ) -> Result {
11963 panic!(concat!(
11964 "Unable to load ",
11965 stringify!(get_memory_win32_handle_properties_khr)
11966 ))
11967 }
11968 let cname = CStr::from_bytes_with_nul_unchecked(
11969 b"vkGetMemoryWin32HandlePropertiesKHR\0",
11970 );
11971 let val = _f(cname);
11972 if val.is_null() {
11973 get_memory_win32_handle_properties_khr
11974 } else {
11975 ::core::mem::transmute(val)
11976 }
11977 },
11978 }
11979 }
11980 }
11981 }
11982 #[doc = "VK_KHR_external_memory_fd"]
11983 pub mod external_memory_fd {
11984 use super::super::*;
11985 pub use {
11986 crate::vk::KHR_EXTERNAL_MEMORY_FD_NAME as NAME,
11987 crate::vk::KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION as SPEC_VERSION,
11988 };
11989 #[doc = "VK_KHR_external_memory_fd device-level functions"]
11990 #[derive(Clone)]
11991 pub struct Device {
11992 pub(crate) fp: DeviceFn,
11993 pub(crate) handle: crate::vk::Device,
11994 }
11995 impl Device {
11996 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
11997 let handle = device.handle();
11998 let fp = DeviceFn::load(|name| unsafe {
11999 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12000 });
12001 Self { handle, fp }
12002 }
12003 #[inline]
12004 pub fn fp(&self) -> &DeviceFn {
12005 &self.fp
12006 }
12007 #[inline]
12008 pub fn device(&self) -> crate::vk::Device {
12009 self.handle
12010 }
12011 }
12012 #[derive(Clone)]
12013 #[doc = "Raw VK_KHR_external_memory_fd device-level function pointers"]
12014 pub struct DeviceFn {
12015 pub get_memory_fd_khr: PFN_vkGetMemoryFdKHR,
12016 pub get_memory_fd_properties_khr: PFN_vkGetMemoryFdPropertiesKHR,
12017 }
12018 unsafe impl Send for DeviceFn {}
12019 unsafe impl Sync for DeviceFn {}
12020 impl DeviceFn {
12021 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12022 Self::load_erased(&mut f)
12023 }
12024 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12025 Self {
12026 get_memory_fd_khr: unsafe {
12027 unsafe extern "system" fn get_memory_fd_khr(
12028 _device: crate::vk::Device,
12029 _p_get_fd_info: *const MemoryGetFdInfoKHR<'_>,
12030 _p_fd: *mut c_int,
12031 ) -> Result {
12032 panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr)))
12033 }
12034 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdKHR\0");
12035 let val = _f(cname);
12036 if val.is_null() {
12037 get_memory_fd_khr
12038 } else {
12039 ::core::mem::transmute(val)
12040 }
12041 },
12042 get_memory_fd_properties_khr: unsafe {
12043 unsafe extern "system" fn get_memory_fd_properties_khr(
12044 _device: crate::vk::Device,
12045 _handle_type: ExternalMemoryHandleTypeFlags,
12046 _fd: c_int,
12047 _p_memory_fd_properties: *mut MemoryFdPropertiesKHR<'_>,
12048 ) -> Result {
12049 panic!(concat!(
12050 "Unable to load ",
12051 stringify!(get_memory_fd_properties_khr)
12052 ))
12053 }
12054 let cname =
12055 CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdPropertiesKHR\0");
12056 let val = _f(cname);
12057 if val.is_null() {
12058 get_memory_fd_properties_khr
12059 } else {
12060 ::core::mem::transmute(val)
12061 }
12062 },
12063 }
12064 }
12065 }
12066 }
12067 #[doc = "VK_KHR_win32_keyed_mutex"]
12068 pub mod win32_keyed_mutex {
12069 use super::super::*;
12070 pub use {
12071 crate::vk::KHR_WIN32_KEYED_MUTEX_NAME as NAME,
12072 crate::vk::KHR_WIN32_KEYED_MUTEX_SPEC_VERSION as SPEC_VERSION,
12073 };
12074 }
12075 #[doc = "VK_KHR_external_semaphore_capabilities"]
12076 pub mod external_semaphore_capabilities {
12077 use super::super::*;
12078 pub use {
12079 crate::vk::KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_NAME as NAME,
12080 crate::vk::KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION as SPEC_VERSION,
12081 };
12082 #[doc = "VK_KHR_external_semaphore_capabilities instance-level functions"]
12083 #[derive(Clone)]
12084 pub struct Instance {
12085 pub(crate) fp: InstanceFn,
12086 pub(crate) handle: crate::vk::Instance,
12087 }
12088 impl Instance {
12089 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
12090 let handle = instance.handle();
12091 let fp = InstanceFn::load(|name| unsafe {
12092 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
12093 });
12094 Self { handle, fp }
12095 }
12096 #[inline]
12097 pub fn fp(&self) -> &InstanceFn {
12098 &self.fp
12099 }
12100 #[inline]
12101 pub fn instance(&self) -> crate::vk::Instance {
12102 self.handle
12103 }
12104 }
12105 #[derive(Clone)]
12106 #[doc = "Raw VK_KHR_external_semaphore_capabilities instance-level function pointers"]
12107 pub struct InstanceFn {
12108 pub get_physical_device_external_semaphore_properties_khr:
12109 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
12110 }
12111 unsafe impl Send for InstanceFn {}
12112 unsafe impl Sync for InstanceFn {}
12113 impl InstanceFn {
12114 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12115 Self::load_erased(&mut f)
12116 }
12117 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12118 Self {
12119 get_physical_device_external_semaphore_properties_khr: unsafe {
12120 unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr(
12121 _physical_device: PhysicalDevice,
12122 _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo<
12123 '_,
12124 >,
12125 _p_external_semaphore_properties: *mut ExternalSemaphoreProperties<'_>,
12126 ) {
12127 panic!(concat!(
12128 "Unable to load ",
12129 stringify!(get_physical_device_external_semaphore_properties_khr)
12130 ))
12131 }
12132 let cname = CStr::from_bytes_with_nul_unchecked(
12133 b"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\0",
12134 );
12135 let val = _f(cname);
12136 if val.is_null() {
12137 get_physical_device_external_semaphore_properties_khr
12138 } else {
12139 ::core::mem::transmute(val)
12140 }
12141 },
12142 }
12143 }
12144 }
12145 }
12146 #[doc = "VK_KHR_external_semaphore"]
12147 pub mod external_semaphore {
12148 use super::super::*;
12149 pub use {
12150 crate::vk::KHR_EXTERNAL_SEMAPHORE_NAME as NAME,
12151 crate::vk::KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION as SPEC_VERSION,
12152 };
12153 }
12154 #[doc = "VK_KHR_external_semaphore_win32"]
12155 pub mod external_semaphore_win32 {
12156 use super::super::*;
12157 pub use {
12158 crate::vk::KHR_EXTERNAL_SEMAPHORE_WIN32_NAME as NAME,
12159 crate::vk::KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION as SPEC_VERSION,
12160 };
12161 #[doc = "VK_KHR_external_semaphore_win32 device-level functions"]
12162 #[derive(Clone)]
12163 pub struct Device {
12164 pub(crate) fp: DeviceFn,
12165 pub(crate) handle: crate::vk::Device,
12166 }
12167 impl Device {
12168 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12169 let handle = device.handle();
12170 let fp = DeviceFn::load(|name| unsafe {
12171 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12172 });
12173 Self { handle, fp }
12174 }
12175 #[inline]
12176 pub fn fp(&self) -> &DeviceFn {
12177 &self.fp
12178 }
12179 #[inline]
12180 pub fn device(&self) -> crate::vk::Device {
12181 self.handle
12182 }
12183 }
12184 #[derive(Clone)]
12185 #[doc = "Raw VK_KHR_external_semaphore_win32 device-level function pointers"]
12186 pub struct DeviceFn {
12187 pub import_semaphore_win32_handle_khr: PFN_vkImportSemaphoreWin32HandleKHR,
12188 pub get_semaphore_win32_handle_khr: PFN_vkGetSemaphoreWin32HandleKHR,
12189 }
12190 unsafe impl Send for DeviceFn {}
12191 unsafe impl Sync for DeviceFn {}
12192 impl DeviceFn {
12193 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12194 Self::load_erased(&mut f)
12195 }
12196 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12197 Self {
12198 import_semaphore_win32_handle_khr: unsafe {
12199 unsafe extern "system" fn import_semaphore_win32_handle_khr(
12200 _device: crate::vk::Device,
12201 _p_import_semaphore_win32_handle_info : * const ImportSemaphoreWin32HandleInfoKHR < '_ >,
12202 ) -> Result {
12203 panic!(concat!(
12204 "Unable to load ",
12205 stringify!(import_semaphore_win32_handle_khr)
12206 ))
12207 }
12208 let cname = CStr::from_bytes_with_nul_unchecked(
12209 b"vkImportSemaphoreWin32HandleKHR\0",
12210 );
12211 let val = _f(cname);
12212 if val.is_null() {
12213 import_semaphore_win32_handle_khr
12214 } else {
12215 ::core::mem::transmute(val)
12216 }
12217 },
12218 get_semaphore_win32_handle_khr: unsafe {
12219 unsafe extern "system" fn get_semaphore_win32_handle_khr(
12220 _device: crate::vk::Device,
12221 _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR<'_>,
12222 _p_handle: *mut HANDLE,
12223 ) -> Result {
12224 panic!(concat!(
12225 "Unable to load ",
12226 stringify!(get_semaphore_win32_handle_khr)
12227 ))
12228 }
12229 let cname =
12230 CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreWin32HandleKHR\0");
12231 let val = _f(cname);
12232 if val.is_null() {
12233 get_semaphore_win32_handle_khr
12234 } else {
12235 ::core::mem::transmute(val)
12236 }
12237 },
12238 }
12239 }
12240 }
12241 }
12242 #[doc = "VK_KHR_external_semaphore_fd"]
12243 pub mod external_semaphore_fd {
12244 use super::super::*;
12245 pub use {
12246 crate::vk::KHR_EXTERNAL_SEMAPHORE_FD_NAME as NAME,
12247 crate::vk::KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION as SPEC_VERSION,
12248 };
12249 #[doc = "VK_KHR_external_semaphore_fd device-level functions"]
12250 #[derive(Clone)]
12251 pub struct Device {
12252 pub(crate) fp: DeviceFn,
12253 pub(crate) handle: crate::vk::Device,
12254 }
12255 impl Device {
12256 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12257 let handle = device.handle();
12258 let fp = DeviceFn::load(|name| unsafe {
12259 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12260 });
12261 Self { handle, fp }
12262 }
12263 #[inline]
12264 pub fn fp(&self) -> &DeviceFn {
12265 &self.fp
12266 }
12267 #[inline]
12268 pub fn device(&self) -> crate::vk::Device {
12269 self.handle
12270 }
12271 }
12272 #[derive(Clone)]
12273 #[doc = "Raw VK_KHR_external_semaphore_fd device-level function pointers"]
12274 pub struct DeviceFn {
12275 pub import_semaphore_fd_khr: PFN_vkImportSemaphoreFdKHR,
12276 pub get_semaphore_fd_khr: PFN_vkGetSemaphoreFdKHR,
12277 }
12278 unsafe impl Send for DeviceFn {}
12279 unsafe impl Sync for DeviceFn {}
12280 impl DeviceFn {
12281 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12282 Self::load_erased(&mut f)
12283 }
12284 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12285 Self {
12286 import_semaphore_fd_khr: unsafe {
12287 unsafe extern "system" fn import_semaphore_fd_khr(
12288 _device: crate::vk::Device,
12289 _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR<'_>,
12290 ) -> Result {
12291 panic!(concat!(
12292 "Unable to load ",
12293 stringify!(import_semaphore_fd_khr)
12294 ))
12295 }
12296 let cname =
12297 CStr::from_bytes_with_nul_unchecked(b"vkImportSemaphoreFdKHR\0");
12298 let val = _f(cname);
12299 if val.is_null() {
12300 import_semaphore_fd_khr
12301 } else {
12302 ::core::mem::transmute(val)
12303 }
12304 },
12305 get_semaphore_fd_khr: unsafe {
12306 unsafe extern "system" fn get_semaphore_fd_khr(
12307 _device: crate::vk::Device,
12308 _p_get_fd_info: *const SemaphoreGetFdInfoKHR<'_>,
12309 _p_fd: *mut c_int,
12310 ) -> Result {
12311 panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr)))
12312 }
12313 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreFdKHR\0");
12314 let val = _f(cname);
12315 if val.is_null() {
12316 get_semaphore_fd_khr
12317 } else {
12318 ::core::mem::transmute(val)
12319 }
12320 },
12321 }
12322 }
12323 }
12324 }
12325 #[doc = "VK_KHR_push_descriptor"]
12326 pub mod push_descriptor {
12327 use super::super::*;
12328 pub use {
12329 crate::vk::KHR_PUSH_DESCRIPTOR_NAME as NAME,
12330 crate::vk::KHR_PUSH_DESCRIPTOR_SPEC_VERSION as SPEC_VERSION,
12331 };
12332 #[doc = "VK_KHR_push_descriptor device-level functions"]
12333 #[derive(Clone)]
12334 pub struct Device {
12335 pub(crate) fp: DeviceFn,
12336 pub(crate) handle: crate::vk::Device,
12337 }
12338 impl Device {
12339 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12340 let handle = device.handle();
12341 let fp = DeviceFn::load(|name| unsafe {
12342 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12343 });
12344 Self { handle, fp }
12345 }
12346 #[inline]
12347 pub fn fp(&self) -> &DeviceFn {
12348 &self.fp
12349 }
12350 #[inline]
12351 pub fn device(&self) -> crate::vk::Device {
12352 self.handle
12353 }
12354 }
12355 #[derive(Clone)]
12356 #[doc = "Raw VK_KHR_push_descriptor device-level function pointers"]
12357 pub struct DeviceFn {
12358 pub cmd_push_descriptor_set_khr: PFN_vkCmdPushDescriptorSetKHR,
12359 pub cmd_push_descriptor_set_with_template_khr:
12360 PFN_vkCmdPushDescriptorSetWithTemplateKHR,
12361 }
12362 unsafe impl Send for DeviceFn {}
12363 unsafe impl Sync for DeviceFn {}
12364 impl DeviceFn {
12365 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12366 Self::load_erased(&mut f)
12367 }
12368 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12369 Self {
12370 cmd_push_descriptor_set_khr: unsafe {
12371 unsafe extern "system" fn cmd_push_descriptor_set_khr(
12372 _command_buffer: CommandBuffer,
12373 _pipeline_bind_point: PipelineBindPoint,
12374 _layout: PipelineLayout,
12375 _set: u32,
12376 _descriptor_write_count: u32,
12377 _p_descriptor_writes: *const WriteDescriptorSet<'_>,
12378 ) {
12379 panic!(concat!(
12380 "Unable to load ",
12381 stringify!(cmd_push_descriptor_set_khr)
12382 ))
12383 }
12384 let cname =
12385 CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSetKHR\0");
12386 let val = _f(cname);
12387 if val.is_null() {
12388 cmd_push_descriptor_set_khr
12389 } else {
12390 ::core::mem::transmute(val)
12391 }
12392 },
12393 cmd_push_descriptor_set_with_template_khr: unsafe {
12394 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
12395 _command_buffer: CommandBuffer,
12396 _descriptor_update_template: DescriptorUpdateTemplate,
12397 _layout: PipelineLayout,
12398 _set: u32,
12399 _p_data: *const c_void,
12400 ) {
12401 panic!(concat!(
12402 "Unable to load ",
12403 stringify!(cmd_push_descriptor_set_with_template_khr)
12404 ))
12405 }
12406 let cname = CStr::from_bytes_with_nul_unchecked(
12407 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
12408 );
12409 let val = _f(cname);
12410 if val.is_null() {
12411 cmd_push_descriptor_set_with_template_khr
12412 } else {
12413 ::core::mem::transmute(val)
12414 }
12415 },
12416 }
12417 }
12418 }
12419 }
12420 #[doc = "VK_KHR_shader_float16_int8"]
12421 pub mod shader_float16_int8 {
12422 use super::super::*;
12423 pub use {
12424 crate::vk::KHR_SHADER_FLOAT16_INT8_NAME as NAME,
12425 crate::vk::KHR_SHADER_FLOAT16_INT8_SPEC_VERSION as SPEC_VERSION,
12426 };
12427 }
12428 #[doc = "VK_KHR_16bit_storage"]
12429 pub mod _16bit_storage {
12430 use super::super::*;
12431 pub use {
12432 crate::vk::KHR_16BIT_STORAGE_NAME as NAME,
12433 crate::vk::KHR_16BIT_STORAGE_SPEC_VERSION as SPEC_VERSION,
12434 };
12435 }
12436 #[doc = "VK_KHR_incremental_present"]
12437 pub mod incremental_present {
12438 use super::super::*;
12439 pub use {
12440 crate::vk::KHR_INCREMENTAL_PRESENT_NAME as NAME,
12441 crate::vk::KHR_INCREMENTAL_PRESENT_SPEC_VERSION as SPEC_VERSION,
12442 };
12443 }
12444 #[doc = "VK_KHR_descriptor_update_template"]
12445 pub mod descriptor_update_template {
12446 use super::super::*;
12447 pub use {
12448 crate::vk::KHR_DESCRIPTOR_UPDATE_TEMPLATE_NAME as NAME,
12449 crate::vk::KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION as SPEC_VERSION,
12450 };
12451 #[doc = "VK_KHR_descriptor_update_template device-level functions"]
12452 #[derive(Clone)]
12453 pub struct Device {
12454 pub(crate) fp: DeviceFn,
12455 pub(crate) handle: crate::vk::Device,
12456 }
12457 impl Device {
12458 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12459 let handle = device.handle();
12460 let fp = DeviceFn::load(|name| unsafe {
12461 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12462 });
12463 Self { handle, fp }
12464 }
12465 #[inline]
12466 pub fn fp(&self) -> &DeviceFn {
12467 &self.fp
12468 }
12469 #[inline]
12470 pub fn device(&self) -> crate::vk::Device {
12471 self.handle
12472 }
12473 }
12474 #[derive(Clone)]
12475 #[doc = "Raw VK_KHR_descriptor_update_template device-level function pointers"]
12476 pub struct DeviceFn {
12477 pub create_descriptor_update_template_khr: PFN_vkCreateDescriptorUpdateTemplate,
12478 pub destroy_descriptor_update_template_khr: PFN_vkDestroyDescriptorUpdateTemplate,
12479 pub update_descriptor_set_with_template_khr: PFN_vkUpdateDescriptorSetWithTemplate,
12480 pub cmd_push_descriptor_set_with_template_khr:
12481 PFN_vkCmdPushDescriptorSetWithTemplateKHR,
12482 }
12483 unsafe impl Send for DeviceFn {}
12484 unsafe impl Sync for DeviceFn {}
12485 impl DeviceFn {
12486 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12487 Self::load_erased(&mut f)
12488 }
12489 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12490 Self {
12491 create_descriptor_update_template_khr: unsafe {
12492 unsafe extern "system" fn create_descriptor_update_template_khr(
12493 _device: crate::vk::Device,
12494 _p_create_info: *const DescriptorUpdateTemplateCreateInfo<'_>,
12495 _p_allocator: *const AllocationCallbacks<'_>,
12496 _p_descriptor_update_template: *mut DescriptorUpdateTemplate,
12497 ) -> Result {
12498 panic!(concat!(
12499 "Unable to load ",
12500 stringify!(create_descriptor_update_template_khr)
12501 ))
12502 }
12503 let cname = CStr::from_bytes_with_nul_unchecked(
12504 b"vkCreateDescriptorUpdateTemplateKHR\0",
12505 );
12506 let val = _f(cname);
12507 if val.is_null() {
12508 create_descriptor_update_template_khr
12509 } else {
12510 ::core::mem::transmute(val)
12511 }
12512 },
12513 destroy_descriptor_update_template_khr: unsafe {
12514 unsafe extern "system" fn destroy_descriptor_update_template_khr(
12515 _device: crate::vk::Device,
12516 _descriptor_update_template: DescriptorUpdateTemplate,
12517 _p_allocator: *const AllocationCallbacks<'_>,
12518 ) {
12519 panic!(concat!(
12520 "Unable to load ",
12521 stringify!(destroy_descriptor_update_template_khr)
12522 ))
12523 }
12524 let cname = CStr::from_bytes_with_nul_unchecked(
12525 b"vkDestroyDescriptorUpdateTemplateKHR\0",
12526 );
12527 let val = _f(cname);
12528 if val.is_null() {
12529 destroy_descriptor_update_template_khr
12530 } else {
12531 ::core::mem::transmute(val)
12532 }
12533 },
12534 update_descriptor_set_with_template_khr: unsafe {
12535 unsafe extern "system" fn update_descriptor_set_with_template_khr(
12536 _device: crate::vk::Device,
12537 _descriptor_set: DescriptorSet,
12538 _descriptor_update_template: DescriptorUpdateTemplate,
12539 _p_data: *const c_void,
12540 ) {
12541 panic!(concat!(
12542 "Unable to load ",
12543 stringify!(update_descriptor_set_with_template_khr)
12544 ))
12545 }
12546 let cname = CStr::from_bytes_with_nul_unchecked(
12547 b"vkUpdateDescriptorSetWithTemplateKHR\0",
12548 );
12549 let val = _f(cname);
12550 if val.is_null() {
12551 update_descriptor_set_with_template_khr
12552 } else {
12553 ::core::mem::transmute(val)
12554 }
12555 },
12556 cmd_push_descriptor_set_with_template_khr: unsafe {
12557 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
12558 _command_buffer: CommandBuffer,
12559 _descriptor_update_template: DescriptorUpdateTemplate,
12560 _layout: PipelineLayout,
12561 _set: u32,
12562 _p_data: *const c_void,
12563 ) {
12564 panic!(concat!(
12565 "Unable to load ",
12566 stringify!(cmd_push_descriptor_set_with_template_khr)
12567 ))
12568 }
12569 let cname = CStr::from_bytes_with_nul_unchecked(
12570 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
12571 );
12572 let val = _f(cname);
12573 if val.is_null() {
12574 cmd_push_descriptor_set_with_template_khr
12575 } else {
12576 ::core::mem::transmute(val)
12577 }
12578 },
12579 }
12580 }
12581 }
12582 }
12583 #[doc = "VK_KHR_imageless_framebuffer"]
12584 pub mod imageless_framebuffer {
12585 use super::super::*;
12586 pub use {
12587 crate::vk::KHR_IMAGELESS_FRAMEBUFFER_NAME as NAME,
12588 crate::vk::KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION as SPEC_VERSION,
12589 };
12590 }
12591 #[doc = "VK_KHR_create_renderpass2"]
12592 pub mod create_renderpass2 {
12593 use super::super::*;
12594 pub use {
12595 crate::vk::KHR_CREATE_RENDERPASS2_NAME as NAME,
12596 crate::vk::KHR_CREATE_RENDERPASS2_SPEC_VERSION as SPEC_VERSION,
12597 };
12598 #[doc = "VK_KHR_create_renderpass2 device-level functions"]
12599 #[derive(Clone)]
12600 pub struct Device {
12601 pub(crate) fp: DeviceFn,
12602 pub(crate) handle: crate::vk::Device,
12603 }
12604 impl Device {
12605 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12606 let handle = device.handle();
12607 let fp = DeviceFn::load(|name| unsafe {
12608 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12609 });
12610 Self { handle, fp }
12611 }
12612 #[inline]
12613 pub fn fp(&self) -> &DeviceFn {
12614 &self.fp
12615 }
12616 #[inline]
12617 pub fn device(&self) -> crate::vk::Device {
12618 self.handle
12619 }
12620 }
12621 #[derive(Clone)]
12622 #[doc = "Raw VK_KHR_create_renderpass2 device-level function pointers"]
12623 pub struct DeviceFn {
12624 pub create_render_pass2_khr: PFN_vkCreateRenderPass2,
12625 pub cmd_begin_render_pass2_khr: PFN_vkCmdBeginRenderPass2,
12626 pub cmd_next_subpass2_khr: PFN_vkCmdNextSubpass2,
12627 pub cmd_end_render_pass2_khr: PFN_vkCmdEndRenderPass2,
12628 }
12629 unsafe impl Send for DeviceFn {}
12630 unsafe impl Sync for DeviceFn {}
12631 impl DeviceFn {
12632 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12633 Self::load_erased(&mut f)
12634 }
12635 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12636 Self {
12637 create_render_pass2_khr: unsafe {
12638 unsafe extern "system" fn create_render_pass2_khr(
12639 _device: crate::vk::Device,
12640 _p_create_info: *const RenderPassCreateInfo2<'_>,
12641 _p_allocator: *const AllocationCallbacks<'_>,
12642 _p_render_pass: *mut RenderPass,
12643 ) -> Result {
12644 panic!(concat!(
12645 "Unable to load ",
12646 stringify!(create_render_pass2_khr)
12647 ))
12648 }
12649 let cname =
12650 CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2KHR\0");
12651 let val = _f(cname);
12652 if val.is_null() {
12653 create_render_pass2_khr
12654 } else {
12655 ::core::mem::transmute(val)
12656 }
12657 },
12658 cmd_begin_render_pass2_khr: unsafe {
12659 unsafe extern "system" fn cmd_begin_render_pass2_khr(
12660 _command_buffer: CommandBuffer,
12661 _p_render_pass_begin: *const RenderPassBeginInfo<'_>,
12662 _p_subpass_begin_info: *const SubpassBeginInfo<'_>,
12663 ) {
12664 panic!(concat!(
12665 "Unable to load ",
12666 stringify!(cmd_begin_render_pass2_khr)
12667 ))
12668 }
12669 let cname =
12670 CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2KHR\0");
12671 let val = _f(cname);
12672 if val.is_null() {
12673 cmd_begin_render_pass2_khr
12674 } else {
12675 ::core::mem::transmute(val)
12676 }
12677 },
12678 cmd_next_subpass2_khr: unsafe {
12679 unsafe extern "system" fn cmd_next_subpass2_khr(
12680 _command_buffer: CommandBuffer,
12681 _p_subpass_begin_info: *const SubpassBeginInfo<'_>,
12682 _p_subpass_end_info: *const SubpassEndInfo<'_>,
12683 ) {
12684 panic!(concat!(
12685 "Unable to load ",
12686 stringify!(cmd_next_subpass2_khr)
12687 ))
12688 }
12689 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2KHR\0");
12690 let val = _f(cname);
12691 if val.is_null() {
12692 cmd_next_subpass2_khr
12693 } else {
12694 ::core::mem::transmute(val)
12695 }
12696 },
12697 cmd_end_render_pass2_khr: unsafe {
12698 unsafe extern "system" fn cmd_end_render_pass2_khr(
12699 _command_buffer: CommandBuffer,
12700 _p_subpass_end_info: *const SubpassEndInfo<'_>,
12701 ) {
12702 panic!(concat!(
12703 "Unable to load ",
12704 stringify!(cmd_end_render_pass2_khr)
12705 ))
12706 }
12707 let cname =
12708 CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2KHR\0");
12709 let val = _f(cname);
12710 if val.is_null() {
12711 cmd_end_render_pass2_khr
12712 } else {
12713 ::core::mem::transmute(val)
12714 }
12715 },
12716 }
12717 }
12718 }
12719 }
12720 #[doc = "VK_KHR_shared_presentable_image"]
12721 pub mod shared_presentable_image {
12722 use super::super::*;
12723 pub use {
12724 crate::vk::KHR_SHARED_PRESENTABLE_IMAGE_NAME as NAME,
12725 crate::vk::KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION as SPEC_VERSION,
12726 };
12727 #[doc = "VK_KHR_shared_presentable_image device-level functions"]
12728 #[derive(Clone)]
12729 pub struct Device {
12730 pub(crate) fp: DeviceFn,
12731 pub(crate) handle: crate::vk::Device,
12732 }
12733 impl Device {
12734 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12735 let handle = device.handle();
12736 let fp = DeviceFn::load(|name| unsafe {
12737 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12738 });
12739 Self { handle, fp }
12740 }
12741 #[inline]
12742 pub fn fp(&self) -> &DeviceFn {
12743 &self.fp
12744 }
12745 #[inline]
12746 pub fn device(&self) -> crate::vk::Device {
12747 self.handle
12748 }
12749 }
12750 #[derive(Clone)]
12751 #[doc = "Raw VK_KHR_shared_presentable_image device-level function pointers"]
12752 pub struct DeviceFn {
12753 pub get_swapchain_status_khr: PFN_vkGetSwapchainStatusKHR,
12754 }
12755 unsafe impl Send for DeviceFn {}
12756 unsafe impl Sync for DeviceFn {}
12757 impl DeviceFn {
12758 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12759 Self::load_erased(&mut f)
12760 }
12761 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12762 Self {
12763 get_swapchain_status_khr: unsafe {
12764 unsafe extern "system" fn get_swapchain_status_khr(
12765 _device: crate::vk::Device,
12766 _swapchain: SwapchainKHR,
12767 ) -> Result {
12768 panic!(concat!(
12769 "Unable to load ",
12770 stringify!(get_swapchain_status_khr)
12771 ))
12772 }
12773 let cname =
12774 CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainStatusKHR\0");
12775 let val = _f(cname);
12776 if val.is_null() {
12777 get_swapchain_status_khr
12778 } else {
12779 ::core::mem::transmute(val)
12780 }
12781 },
12782 }
12783 }
12784 }
12785 }
12786 #[doc = "VK_KHR_external_fence_capabilities"]
12787 pub mod external_fence_capabilities {
12788 use super::super::*;
12789 pub use {
12790 crate::vk::KHR_EXTERNAL_FENCE_CAPABILITIES_NAME as NAME,
12791 crate::vk::KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION as SPEC_VERSION,
12792 };
12793 #[doc = "VK_KHR_external_fence_capabilities instance-level functions"]
12794 #[derive(Clone)]
12795 pub struct Instance {
12796 pub(crate) fp: InstanceFn,
12797 pub(crate) handle: crate::vk::Instance,
12798 }
12799 impl Instance {
12800 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
12801 let handle = instance.handle();
12802 let fp = InstanceFn::load(|name| unsafe {
12803 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
12804 });
12805 Self { handle, fp }
12806 }
12807 #[inline]
12808 pub fn fp(&self) -> &InstanceFn {
12809 &self.fp
12810 }
12811 #[inline]
12812 pub fn instance(&self) -> crate::vk::Instance {
12813 self.handle
12814 }
12815 }
12816 #[derive(Clone)]
12817 #[doc = "Raw VK_KHR_external_fence_capabilities instance-level function pointers"]
12818 pub struct InstanceFn {
12819 pub get_physical_device_external_fence_properties_khr:
12820 PFN_vkGetPhysicalDeviceExternalFenceProperties,
12821 }
12822 unsafe impl Send for InstanceFn {}
12823 unsafe impl Sync for InstanceFn {}
12824 impl InstanceFn {
12825 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12826 Self::load_erased(&mut f)
12827 }
12828 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12829 Self {
12830 get_physical_device_external_fence_properties_khr: unsafe {
12831 unsafe extern "system" fn get_physical_device_external_fence_properties_khr(
12832 _physical_device: PhysicalDevice,
12833 _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo<'_>,
12834 _p_external_fence_properties: *mut ExternalFenceProperties<'_>,
12835 ) {
12836 panic!(concat!(
12837 "Unable to load ",
12838 stringify!(get_physical_device_external_fence_properties_khr)
12839 ))
12840 }
12841 let cname = CStr::from_bytes_with_nul_unchecked(
12842 b"vkGetPhysicalDeviceExternalFencePropertiesKHR\0",
12843 );
12844 let val = _f(cname);
12845 if val.is_null() {
12846 get_physical_device_external_fence_properties_khr
12847 } else {
12848 ::core::mem::transmute(val)
12849 }
12850 },
12851 }
12852 }
12853 }
12854 }
12855 #[doc = "VK_KHR_external_fence"]
12856 pub mod external_fence {
12857 use super::super::*;
12858 pub use {
12859 crate::vk::KHR_EXTERNAL_FENCE_NAME as NAME,
12860 crate::vk::KHR_EXTERNAL_FENCE_SPEC_VERSION as SPEC_VERSION,
12861 };
12862 }
12863 #[doc = "VK_KHR_external_fence_win32"]
12864 pub mod external_fence_win32 {
12865 use super::super::*;
12866 pub use {
12867 crate::vk::KHR_EXTERNAL_FENCE_WIN32_NAME as NAME,
12868 crate::vk::KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION as SPEC_VERSION,
12869 };
12870 #[doc = "VK_KHR_external_fence_win32 device-level functions"]
12871 #[derive(Clone)]
12872 pub struct Device {
12873 pub(crate) fp: DeviceFn,
12874 pub(crate) handle: crate::vk::Device,
12875 }
12876 impl Device {
12877 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12878 let handle = device.handle();
12879 let fp = DeviceFn::load(|name| unsafe {
12880 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12881 });
12882 Self { handle, fp }
12883 }
12884 #[inline]
12885 pub fn fp(&self) -> &DeviceFn {
12886 &self.fp
12887 }
12888 #[inline]
12889 pub fn device(&self) -> crate::vk::Device {
12890 self.handle
12891 }
12892 }
12893 #[derive(Clone)]
12894 #[doc = "Raw VK_KHR_external_fence_win32 device-level function pointers"]
12895 pub struct DeviceFn {
12896 pub import_fence_win32_handle_khr: PFN_vkImportFenceWin32HandleKHR,
12897 pub get_fence_win32_handle_khr: PFN_vkGetFenceWin32HandleKHR,
12898 }
12899 unsafe impl Send for DeviceFn {}
12900 unsafe impl Sync for DeviceFn {}
12901 impl DeviceFn {
12902 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12903 Self::load_erased(&mut f)
12904 }
12905 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12906 Self {
12907 import_fence_win32_handle_khr: unsafe {
12908 unsafe extern "system" fn import_fence_win32_handle_khr(
12909 _device: crate::vk::Device,
12910 _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR<
12911 '_,
12912 >,
12913 ) -> Result {
12914 panic!(concat!(
12915 "Unable to load ",
12916 stringify!(import_fence_win32_handle_khr)
12917 ))
12918 }
12919 let cname =
12920 CStr::from_bytes_with_nul_unchecked(b"vkImportFenceWin32HandleKHR\0");
12921 let val = _f(cname);
12922 if val.is_null() {
12923 import_fence_win32_handle_khr
12924 } else {
12925 ::core::mem::transmute(val)
12926 }
12927 },
12928 get_fence_win32_handle_khr: unsafe {
12929 unsafe extern "system" fn get_fence_win32_handle_khr(
12930 _device: crate::vk::Device,
12931 _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR<'_>,
12932 _p_handle: *mut HANDLE,
12933 ) -> Result {
12934 panic!(concat!(
12935 "Unable to load ",
12936 stringify!(get_fence_win32_handle_khr)
12937 ))
12938 }
12939 let cname =
12940 CStr::from_bytes_with_nul_unchecked(b"vkGetFenceWin32HandleKHR\0");
12941 let val = _f(cname);
12942 if val.is_null() {
12943 get_fence_win32_handle_khr
12944 } else {
12945 ::core::mem::transmute(val)
12946 }
12947 },
12948 }
12949 }
12950 }
12951 }
12952 #[doc = "VK_KHR_external_fence_fd"]
12953 pub mod external_fence_fd {
12954 use super::super::*;
12955 pub use {
12956 crate::vk::KHR_EXTERNAL_FENCE_FD_NAME as NAME,
12957 crate::vk::KHR_EXTERNAL_FENCE_FD_SPEC_VERSION as SPEC_VERSION,
12958 };
12959 #[doc = "VK_KHR_external_fence_fd device-level functions"]
12960 #[derive(Clone)]
12961 pub struct Device {
12962 pub(crate) fp: DeviceFn,
12963 pub(crate) handle: crate::vk::Device,
12964 }
12965 impl Device {
12966 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
12967 let handle = device.handle();
12968 let fp = DeviceFn::load(|name| unsafe {
12969 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
12970 });
12971 Self { handle, fp }
12972 }
12973 #[inline]
12974 pub fn fp(&self) -> &DeviceFn {
12975 &self.fp
12976 }
12977 #[inline]
12978 pub fn device(&self) -> crate::vk::Device {
12979 self.handle
12980 }
12981 }
12982 #[derive(Clone)]
12983 #[doc = "Raw VK_KHR_external_fence_fd device-level function pointers"]
12984 pub struct DeviceFn {
12985 pub import_fence_fd_khr: PFN_vkImportFenceFdKHR,
12986 pub get_fence_fd_khr: PFN_vkGetFenceFdKHR,
12987 }
12988 unsafe impl Send for DeviceFn {}
12989 unsafe impl Sync for DeviceFn {}
12990 impl DeviceFn {
12991 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
12992 Self::load_erased(&mut f)
12993 }
12994 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
12995 Self {
12996 import_fence_fd_khr: unsafe {
12997 unsafe extern "system" fn import_fence_fd_khr(
12998 _device: crate::vk::Device,
12999 _p_import_fence_fd_info: *const ImportFenceFdInfoKHR<'_>,
13000 ) -> Result {
13001 panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr)))
13002 }
13003 let cname = CStr::from_bytes_with_nul_unchecked(b"vkImportFenceFdKHR\0");
13004 let val = _f(cname);
13005 if val.is_null() {
13006 import_fence_fd_khr
13007 } else {
13008 ::core::mem::transmute(val)
13009 }
13010 },
13011 get_fence_fd_khr: unsafe {
13012 unsafe extern "system" fn get_fence_fd_khr(
13013 _device: crate::vk::Device,
13014 _p_get_fd_info: *const FenceGetFdInfoKHR<'_>,
13015 _p_fd: *mut c_int,
13016 ) -> Result {
13017 panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr)))
13018 }
13019 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetFenceFdKHR\0");
13020 let val = _f(cname);
13021 if val.is_null() {
13022 get_fence_fd_khr
13023 } else {
13024 ::core::mem::transmute(val)
13025 }
13026 },
13027 }
13028 }
13029 }
13030 }
13031 #[doc = "VK_KHR_performance_query"]
13032 pub mod performance_query {
13033 use super::super::*;
13034 pub use {
13035 crate::vk::KHR_PERFORMANCE_QUERY_NAME as NAME,
13036 crate::vk::KHR_PERFORMANCE_QUERY_SPEC_VERSION as SPEC_VERSION,
13037 };
13038 #[doc = "VK_KHR_performance_query instance-level functions"]
13039 #[derive(Clone)]
13040 pub struct Instance {
13041 pub(crate) fp: InstanceFn,
13042 pub(crate) handle: crate::vk::Instance,
13043 }
13044 impl Instance {
13045 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
13046 let handle = instance.handle();
13047 let fp = InstanceFn::load(|name| unsafe {
13048 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
13049 });
13050 Self { handle, fp }
13051 }
13052 #[inline]
13053 pub fn fp(&self) -> &InstanceFn {
13054 &self.fp
13055 }
13056 #[inline]
13057 pub fn instance(&self) -> crate::vk::Instance {
13058 self.handle
13059 }
13060 }
13061 #[derive(Clone)]
13062 #[doc = "Raw VK_KHR_performance_query instance-level function pointers"]
13063 pub struct InstanceFn {
13064 pub enumerate_physical_device_queue_family_performance_query_counters_khr:
13065 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
13066 pub get_physical_device_queue_family_performance_query_passes_khr:
13067 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
13068 }
13069 unsafe impl Send for InstanceFn {}
13070 unsafe impl Sync for InstanceFn {}
13071 impl InstanceFn {
13072 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13073 Self::load_erased(&mut f)
13074 }
13075 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13076 Self {
13077 enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe {
13078 unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr(
13079 _physical_device: PhysicalDevice,
13080 _queue_family_index: u32,
13081 _p_counter_count: *mut u32,
13082 _p_counters: *mut PerformanceCounterKHR<'_>,
13083 _p_counter_descriptions: *mut PerformanceCounterDescriptionKHR<'_>,
13084 ) -> Result {
13085 panic ! (concat ! ("Unable to load " , stringify ! (enumerate_physical_device_queue_family_performance_query_counters_khr)))
13086 }
13087 let cname = CStr::from_bytes_with_nul_unchecked(
13088 b"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\0",
13089 );
13090 let val = _f(cname);
13091 if val.is_null() {
13092 enumerate_physical_device_queue_family_performance_query_counters_khr
13093 } else {
13094 ::core::mem::transmute(val)
13095 }
13096 },
13097 get_physical_device_queue_family_performance_query_passes_khr: unsafe {
13098 unsafe extern "system" fn get_physical_device_queue_family_performance_query_passes_khr(
13099 _physical_device: PhysicalDevice,
13100 _p_performance_query_create_info : * const QueryPoolPerformanceCreateInfoKHR < '_ >,
13101 _p_num_passes: *mut u32,
13102 ) {
13103 panic!(concat!(
13104 "Unable to load ",
13105 stringify!(
13106 get_physical_device_queue_family_performance_query_passes_khr
13107 )
13108 ))
13109 }
13110 let cname = CStr::from_bytes_with_nul_unchecked(
13111 b"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\0",
13112 );
13113 let val = _f(cname);
13114 if val.is_null() {
13115 get_physical_device_queue_family_performance_query_passes_khr
13116 } else {
13117 ::core::mem::transmute(val)
13118 }
13119 },
13120 }
13121 }
13122 }
13123 #[doc = "VK_KHR_performance_query device-level functions"]
13124 #[derive(Clone)]
13125 pub struct Device {
13126 pub(crate) fp: DeviceFn,
13127 pub(crate) handle: crate::vk::Device,
13128 }
13129 impl Device {
13130 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
13131 let handle = device.handle();
13132 let fp = DeviceFn::load(|name| unsafe {
13133 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
13134 });
13135 Self { handle, fp }
13136 }
13137 #[inline]
13138 pub fn fp(&self) -> &DeviceFn {
13139 &self.fp
13140 }
13141 #[inline]
13142 pub fn device(&self) -> crate::vk::Device {
13143 self.handle
13144 }
13145 }
13146 #[derive(Clone)]
13147 #[doc = "Raw VK_KHR_performance_query device-level function pointers"]
13148 pub struct DeviceFn {
13149 pub acquire_profiling_lock_khr: PFN_vkAcquireProfilingLockKHR,
13150 pub release_profiling_lock_khr: PFN_vkReleaseProfilingLockKHR,
13151 }
13152 unsafe impl Send for DeviceFn {}
13153 unsafe impl Sync for DeviceFn {}
13154 impl DeviceFn {
13155 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13156 Self::load_erased(&mut f)
13157 }
13158 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13159 Self {
13160 acquire_profiling_lock_khr: unsafe {
13161 unsafe extern "system" fn acquire_profiling_lock_khr(
13162 _device: crate::vk::Device,
13163 _p_info: *const AcquireProfilingLockInfoKHR<'_>,
13164 ) -> Result {
13165 panic!(concat!(
13166 "Unable to load ",
13167 stringify!(acquire_profiling_lock_khr)
13168 ))
13169 }
13170 let cname =
13171 CStr::from_bytes_with_nul_unchecked(b"vkAcquireProfilingLockKHR\0");
13172 let val = _f(cname);
13173 if val.is_null() {
13174 acquire_profiling_lock_khr
13175 } else {
13176 ::core::mem::transmute(val)
13177 }
13178 },
13179 release_profiling_lock_khr: unsafe {
13180 unsafe extern "system" fn release_profiling_lock_khr(
13181 _device: crate::vk::Device,
13182 ) {
13183 panic!(concat!(
13184 "Unable to load ",
13185 stringify!(release_profiling_lock_khr)
13186 ))
13187 }
13188 let cname =
13189 CStr::from_bytes_with_nul_unchecked(b"vkReleaseProfilingLockKHR\0");
13190 let val = _f(cname);
13191 if val.is_null() {
13192 release_profiling_lock_khr
13193 } else {
13194 ::core::mem::transmute(val)
13195 }
13196 },
13197 }
13198 }
13199 }
13200 }
13201 #[doc = "VK_KHR_maintenance2"]
13202 pub mod maintenance2 {
13203 use super::super::*;
13204 pub use {
13205 crate::vk::KHR_MAINTENANCE2_NAME as NAME,
13206 crate::vk::KHR_MAINTENANCE2_SPEC_VERSION as SPEC_VERSION,
13207 };
13208 }
13209 #[doc = "VK_KHR_get_surface_capabilities2"]
13210 pub mod get_surface_capabilities2 {
13211 use super::super::*;
13212 pub use {
13213 crate::vk::KHR_GET_SURFACE_CAPABILITIES2_NAME as NAME,
13214 crate::vk::KHR_GET_SURFACE_CAPABILITIES2_SPEC_VERSION as SPEC_VERSION,
13215 };
13216 #[doc = "VK_KHR_get_surface_capabilities2 instance-level functions"]
13217 #[derive(Clone)]
13218 pub struct Instance {
13219 pub(crate) fp: InstanceFn,
13220 pub(crate) handle: crate::vk::Instance,
13221 }
13222 impl Instance {
13223 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
13224 let handle = instance.handle();
13225 let fp = InstanceFn::load(|name| unsafe {
13226 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
13227 });
13228 Self { handle, fp }
13229 }
13230 #[inline]
13231 pub fn fp(&self) -> &InstanceFn {
13232 &self.fp
13233 }
13234 #[inline]
13235 pub fn instance(&self) -> crate::vk::Instance {
13236 self.handle
13237 }
13238 }
13239 #[derive(Clone)]
13240 #[doc = "Raw VK_KHR_get_surface_capabilities2 instance-level function pointers"]
13241 pub struct InstanceFn {
13242 pub get_physical_device_surface_capabilities2_khr:
13243 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
13244 pub get_physical_device_surface_formats2_khr: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR,
13245 }
13246 unsafe impl Send for InstanceFn {}
13247 unsafe impl Sync for InstanceFn {}
13248 impl InstanceFn {
13249 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13250 Self::load_erased(&mut f)
13251 }
13252 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13253 Self {
13254 get_physical_device_surface_capabilities2_khr: unsafe {
13255 unsafe extern "system" fn get_physical_device_surface_capabilities2_khr(
13256 _physical_device: PhysicalDevice,
13257 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
13258 _p_surface_capabilities: *mut SurfaceCapabilities2KHR<'_>,
13259 ) -> Result {
13260 panic!(concat!(
13261 "Unable to load ",
13262 stringify!(get_physical_device_surface_capabilities2_khr)
13263 ))
13264 }
13265 let cname = CStr::from_bytes_with_nul_unchecked(
13266 b"vkGetPhysicalDeviceSurfaceCapabilities2KHR\0",
13267 );
13268 let val = _f(cname);
13269 if val.is_null() {
13270 get_physical_device_surface_capabilities2_khr
13271 } else {
13272 ::core::mem::transmute(val)
13273 }
13274 },
13275 get_physical_device_surface_formats2_khr: unsafe {
13276 unsafe extern "system" fn get_physical_device_surface_formats2_khr(
13277 _physical_device: PhysicalDevice,
13278 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
13279 _p_surface_format_count: *mut u32,
13280 _p_surface_formats: *mut SurfaceFormat2KHR<'_>,
13281 ) -> Result {
13282 panic!(concat!(
13283 "Unable to load ",
13284 stringify!(get_physical_device_surface_formats2_khr)
13285 ))
13286 }
13287 let cname = CStr::from_bytes_with_nul_unchecked(
13288 b"vkGetPhysicalDeviceSurfaceFormats2KHR\0",
13289 );
13290 let val = _f(cname);
13291 if val.is_null() {
13292 get_physical_device_surface_formats2_khr
13293 } else {
13294 ::core::mem::transmute(val)
13295 }
13296 },
13297 }
13298 }
13299 }
13300 }
13301 #[doc = "VK_KHR_variable_pointers"]
13302 pub mod variable_pointers {
13303 use super::super::*;
13304 pub use {
13305 crate::vk::KHR_VARIABLE_POINTERS_NAME as NAME,
13306 crate::vk::KHR_VARIABLE_POINTERS_SPEC_VERSION as SPEC_VERSION,
13307 };
13308 }
13309 #[doc = "VK_KHR_get_display_properties2"]
13310 pub mod get_display_properties2 {
13311 use super::super::*;
13312 pub use {
13313 crate::vk::KHR_GET_DISPLAY_PROPERTIES2_NAME as NAME,
13314 crate::vk::KHR_GET_DISPLAY_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
13315 };
13316 #[doc = "VK_KHR_get_display_properties2 instance-level functions"]
13317 #[derive(Clone)]
13318 pub struct Instance {
13319 pub(crate) fp: InstanceFn,
13320 pub(crate) handle: crate::vk::Instance,
13321 }
13322 impl Instance {
13323 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
13324 let handle = instance.handle();
13325 let fp = InstanceFn::load(|name| unsafe {
13326 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
13327 });
13328 Self { handle, fp }
13329 }
13330 #[inline]
13331 pub fn fp(&self) -> &InstanceFn {
13332 &self.fp
13333 }
13334 #[inline]
13335 pub fn instance(&self) -> crate::vk::Instance {
13336 self.handle
13337 }
13338 }
13339 #[derive(Clone)]
13340 #[doc = "Raw VK_KHR_get_display_properties2 instance-level function pointers"]
13341 pub struct InstanceFn {
13342 pub get_physical_device_display_properties2_khr:
13343 PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
13344 pub get_physical_device_display_plane_properties2_khr:
13345 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
13346 pub get_display_mode_properties2_khr: PFN_vkGetDisplayModeProperties2KHR,
13347 pub get_display_plane_capabilities2_khr: PFN_vkGetDisplayPlaneCapabilities2KHR,
13348 }
13349 unsafe impl Send for InstanceFn {}
13350 unsafe impl Sync for InstanceFn {}
13351 impl InstanceFn {
13352 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13353 Self::load_erased(&mut f)
13354 }
13355 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13356 Self {
13357 get_physical_device_display_properties2_khr: unsafe {
13358 unsafe extern "system" fn get_physical_device_display_properties2_khr(
13359 _physical_device: PhysicalDevice,
13360 _p_property_count: *mut u32,
13361 _p_properties: *mut DisplayProperties2KHR<'_>,
13362 ) -> Result {
13363 panic!(concat!(
13364 "Unable to load ",
13365 stringify!(get_physical_device_display_properties2_khr)
13366 ))
13367 }
13368 let cname = CStr::from_bytes_with_nul_unchecked(
13369 b"vkGetPhysicalDeviceDisplayProperties2KHR\0",
13370 );
13371 let val = _f(cname);
13372 if val.is_null() {
13373 get_physical_device_display_properties2_khr
13374 } else {
13375 ::core::mem::transmute(val)
13376 }
13377 },
13378 get_physical_device_display_plane_properties2_khr: unsafe {
13379 unsafe extern "system" fn get_physical_device_display_plane_properties2_khr(
13380 _physical_device: PhysicalDevice,
13381 _p_property_count: *mut u32,
13382 _p_properties: *mut DisplayPlaneProperties2KHR<'_>,
13383 ) -> Result {
13384 panic!(concat!(
13385 "Unable to load ",
13386 stringify!(get_physical_device_display_plane_properties2_khr)
13387 ))
13388 }
13389 let cname = CStr::from_bytes_with_nul_unchecked(
13390 b"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\0",
13391 );
13392 let val = _f(cname);
13393 if val.is_null() {
13394 get_physical_device_display_plane_properties2_khr
13395 } else {
13396 ::core::mem::transmute(val)
13397 }
13398 },
13399 get_display_mode_properties2_khr: unsafe {
13400 unsafe extern "system" fn get_display_mode_properties2_khr(
13401 _physical_device: PhysicalDevice,
13402 _display: DisplayKHR,
13403 _p_property_count: *mut u32,
13404 _p_properties: *mut DisplayModeProperties2KHR<'_>,
13405 ) -> Result {
13406 panic!(concat!(
13407 "Unable to load ",
13408 stringify!(get_display_mode_properties2_khr)
13409 ))
13410 }
13411 let cname = CStr::from_bytes_with_nul_unchecked(
13412 b"vkGetDisplayModeProperties2KHR\0",
13413 );
13414 let val = _f(cname);
13415 if val.is_null() {
13416 get_display_mode_properties2_khr
13417 } else {
13418 ::core::mem::transmute(val)
13419 }
13420 },
13421 get_display_plane_capabilities2_khr: unsafe {
13422 unsafe extern "system" fn get_display_plane_capabilities2_khr(
13423 _physical_device: PhysicalDevice,
13424 _p_display_plane_info: *const DisplayPlaneInfo2KHR<'_>,
13425 _p_capabilities: *mut DisplayPlaneCapabilities2KHR<'_>,
13426 ) -> Result {
13427 panic!(concat!(
13428 "Unable to load ",
13429 stringify!(get_display_plane_capabilities2_khr)
13430 ))
13431 }
13432 let cname = CStr::from_bytes_with_nul_unchecked(
13433 b"vkGetDisplayPlaneCapabilities2KHR\0",
13434 );
13435 let val = _f(cname);
13436 if val.is_null() {
13437 get_display_plane_capabilities2_khr
13438 } else {
13439 ::core::mem::transmute(val)
13440 }
13441 },
13442 }
13443 }
13444 }
13445 }
13446 #[doc = "VK_KHR_dedicated_allocation"]
13447 pub mod dedicated_allocation {
13448 use super::super::*;
13449 pub use {
13450 crate::vk::KHR_DEDICATED_ALLOCATION_NAME as NAME,
13451 crate::vk::KHR_DEDICATED_ALLOCATION_SPEC_VERSION as SPEC_VERSION,
13452 };
13453 }
13454 #[doc = "VK_KHR_storage_buffer_storage_class"]
13455 pub mod storage_buffer_storage_class {
13456 use super::super::*;
13457 pub use {
13458 crate::vk::KHR_STORAGE_BUFFER_STORAGE_CLASS_NAME as NAME,
13459 crate::vk::KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION as SPEC_VERSION,
13460 };
13461 }
13462 #[doc = "VK_KHR_relaxed_block_layout"]
13463 pub mod relaxed_block_layout {
13464 use super::super::*;
13465 pub use {
13466 crate::vk::KHR_RELAXED_BLOCK_LAYOUT_NAME as NAME,
13467 crate::vk::KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION as SPEC_VERSION,
13468 };
13469 }
13470 #[doc = "VK_KHR_get_memory_requirements2"]
13471 pub mod get_memory_requirements2 {
13472 use super::super::*;
13473 pub use {
13474 crate::vk::KHR_GET_MEMORY_REQUIREMENTS2_NAME as NAME,
13475 crate::vk::KHR_GET_MEMORY_REQUIREMENTS2_SPEC_VERSION as SPEC_VERSION,
13476 };
13477 #[doc = "VK_KHR_get_memory_requirements2 device-level functions"]
13478 #[derive(Clone)]
13479 pub struct Device {
13480 pub(crate) fp: DeviceFn,
13481 pub(crate) handle: crate::vk::Device,
13482 }
13483 impl Device {
13484 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
13485 let handle = device.handle();
13486 let fp = DeviceFn::load(|name| unsafe {
13487 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
13488 });
13489 Self { handle, fp }
13490 }
13491 #[inline]
13492 pub fn fp(&self) -> &DeviceFn {
13493 &self.fp
13494 }
13495 #[inline]
13496 pub fn device(&self) -> crate::vk::Device {
13497 self.handle
13498 }
13499 }
13500 #[derive(Clone)]
13501 #[doc = "Raw VK_KHR_get_memory_requirements2 device-level function pointers"]
13502 pub struct DeviceFn {
13503 pub get_image_memory_requirements2_khr: PFN_vkGetImageMemoryRequirements2,
13504 pub get_buffer_memory_requirements2_khr: PFN_vkGetBufferMemoryRequirements2,
13505 pub get_image_sparse_memory_requirements2_khr: PFN_vkGetImageSparseMemoryRequirements2,
13506 }
13507 unsafe impl Send for DeviceFn {}
13508 unsafe impl Sync for DeviceFn {}
13509 impl DeviceFn {
13510 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13511 Self::load_erased(&mut f)
13512 }
13513 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13514 Self {
13515 get_image_memory_requirements2_khr: unsafe {
13516 unsafe extern "system" fn get_image_memory_requirements2_khr(
13517 _device: crate::vk::Device,
13518 _p_info: *const ImageMemoryRequirementsInfo2<'_>,
13519 _p_memory_requirements: *mut MemoryRequirements2<'_>,
13520 ) {
13521 panic!(concat!(
13522 "Unable to load ",
13523 stringify!(get_image_memory_requirements2_khr)
13524 ))
13525 }
13526 let cname = CStr::from_bytes_with_nul_unchecked(
13527 b"vkGetImageMemoryRequirements2KHR\0",
13528 );
13529 let val = _f(cname);
13530 if val.is_null() {
13531 get_image_memory_requirements2_khr
13532 } else {
13533 ::core::mem::transmute(val)
13534 }
13535 },
13536 get_buffer_memory_requirements2_khr: unsafe {
13537 unsafe extern "system" fn get_buffer_memory_requirements2_khr(
13538 _device: crate::vk::Device,
13539 _p_info: *const BufferMemoryRequirementsInfo2<'_>,
13540 _p_memory_requirements: *mut MemoryRequirements2<'_>,
13541 ) {
13542 panic!(concat!(
13543 "Unable to load ",
13544 stringify!(get_buffer_memory_requirements2_khr)
13545 ))
13546 }
13547 let cname = CStr::from_bytes_with_nul_unchecked(
13548 b"vkGetBufferMemoryRequirements2KHR\0",
13549 );
13550 let val = _f(cname);
13551 if val.is_null() {
13552 get_buffer_memory_requirements2_khr
13553 } else {
13554 ::core::mem::transmute(val)
13555 }
13556 },
13557 get_image_sparse_memory_requirements2_khr: unsafe {
13558 unsafe extern "system" fn get_image_sparse_memory_requirements2_khr(
13559 _device: crate::vk::Device,
13560 _p_info: *const ImageSparseMemoryRequirementsInfo2<'_>,
13561 _p_sparse_memory_requirement_count: *mut u32,
13562 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2<'_>,
13563 ) {
13564 panic!(concat!(
13565 "Unable to load ",
13566 stringify!(get_image_sparse_memory_requirements2_khr)
13567 ))
13568 }
13569 let cname = CStr::from_bytes_with_nul_unchecked(
13570 b"vkGetImageSparseMemoryRequirements2KHR\0",
13571 );
13572 let val = _f(cname);
13573 if val.is_null() {
13574 get_image_sparse_memory_requirements2_khr
13575 } else {
13576 ::core::mem::transmute(val)
13577 }
13578 },
13579 }
13580 }
13581 }
13582 }
13583 #[doc = "VK_KHR_image_format_list"]
13584 pub mod image_format_list {
13585 use super::super::*;
13586 pub use {
13587 crate::vk::KHR_IMAGE_FORMAT_LIST_NAME as NAME,
13588 crate::vk::KHR_IMAGE_FORMAT_LIST_SPEC_VERSION as SPEC_VERSION,
13589 };
13590 }
13591 #[doc = "VK_KHR_acceleration_structure"]
13592 pub mod acceleration_structure {
13593 use super::super::*;
13594 pub use {
13595 crate::vk::KHR_ACCELERATION_STRUCTURE_NAME as NAME,
13596 crate::vk::KHR_ACCELERATION_STRUCTURE_SPEC_VERSION as SPEC_VERSION,
13597 };
13598 #[doc = "VK_KHR_acceleration_structure device-level functions"]
13599 #[derive(Clone)]
13600 pub struct Device {
13601 pub(crate) fp: DeviceFn,
13602 pub(crate) handle: crate::vk::Device,
13603 }
13604 impl Device {
13605 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
13606 let handle = device.handle();
13607 let fp = DeviceFn::load(|name| unsafe {
13608 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
13609 });
13610 Self { handle, fp }
13611 }
13612 #[inline]
13613 pub fn fp(&self) -> &DeviceFn {
13614 &self.fp
13615 }
13616 #[inline]
13617 pub fn device(&self) -> crate::vk::Device {
13618 self.handle
13619 }
13620 }
13621 #[derive(Clone)]
13622 #[doc = "Raw VK_KHR_acceleration_structure device-level function pointers"]
13623 pub struct DeviceFn {
13624 pub create_acceleration_structure_khr: PFN_vkCreateAccelerationStructureKHR,
13625 pub destroy_acceleration_structure_khr: PFN_vkDestroyAccelerationStructureKHR,
13626 pub cmd_build_acceleration_structures_khr: PFN_vkCmdBuildAccelerationStructuresKHR,
13627 pub cmd_build_acceleration_structures_indirect_khr:
13628 PFN_vkCmdBuildAccelerationStructuresIndirectKHR,
13629 pub build_acceleration_structures_khr: PFN_vkBuildAccelerationStructuresKHR,
13630 pub copy_acceleration_structure_khr: PFN_vkCopyAccelerationStructureKHR,
13631 pub copy_acceleration_structure_to_memory_khr:
13632 PFN_vkCopyAccelerationStructureToMemoryKHR,
13633 pub copy_memory_to_acceleration_structure_khr:
13634 PFN_vkCopyMemoryToAccelerationStructureKHR,
13635 pub write_acceleration_structures_properties_khr:
13636 PFN_vkWriteAccelerationStructuresPropertiesKHR,
13637 pub cmd_copy_acceleration_structure_khr: PFN_vkCmdCopyAccelerationStructureKHR,
13638 pub cmd_copy_acceleration_structure_to_memory_khr:
13639 PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
13640 pub cmd_copy_memory_to_acceleration_structure_khr:
13641 PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
13642 pub get_acceleration_structure_device_address_khr:
13643 PFN_vkGetAccelerationStructureDeviceAddressKHR,
13644 pub cmd_write_acceleration_structures_properties_khr:
13645 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
13646 pub get_device_acceleration_structure_compatibility_khr:
13647 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
13648 pub get_acceleration_structure_build_sizes_khr:
13649 PFN_vkGetAccelerationStructureBuildSizesKHR,
13650 }
13651 unsafe impl Send for DeviceFn {}
13652 unsafe impl Sync for DeviceFn {}
13653 impl DeviceFn {
13654 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
13655 Self::load_erased(&mut f)
13656 }
13657 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
13658 Self {
13659 create_acceleration_structure_khr: unsafe {
13660 unsafe extern "system" fn create_acceleration_structure_khr(
13661 _device: crate::vk::Device,
13662 _p_create_info: *const AccelerationStructureCreateInfoKHR<'_>,
13663 _p_allocator: *const AllocationCallbacks<'_>,
13664 _p_acceleration_structure: *mut AccelerationStructureKHR,
13665 ) -> Result {
13666 panic!(concat!(
13667 "Unable to load ",
13668 stringify!(create_acceleration_structure_khr)
13669 ))
13670 }
13671 let cname = CStr::from_bytes_with_nul_unchecked(
13672 b"vkCreateAccelerationStructureKHR\0",
13673 );
13674 let val = _f(cname);
13675 if val.is_null() {
13676 create_acceleration_structure_khr
13677 } else {
13678 ::core::mem::transmute(val)
13679 }
13680 },
13681 destroy_acceleration_structure_khr: unsafe {
13682 unsafe extern "system" fn destroy_acceleration_structure_khr(
13683 _device: crate::vk::Device,
13684 _acceleration_structure: AccelerationStructureKHR,
13685 _p_allocator: *const AllocationCallbacks<'_>,
13686 ) {
13687 panic!(concat!(
13688 "Unable to load ",
13689 stringify!(destroy_acceleration_structure_khr)
13690 ))
13691 }
13692 let cname = CStr::from_bytes_with_nul_unchecked(
13693 b"vkDestroyAccelerationStructureKHR\0",
13694 );
13695 let val = _f(cname);
13696 if val.is_null() {
13697 destroy_acceleration_structure_khr
13698 } else {
13699 ::core::mem::transmute(val)
13700 }
13701 },
13702 cmd_build_acceleration_structures_khr: unsafe {
13703 unsafe extern "system" fn cmd_build_acceleration_structures_khr(
13704 _command_buffer: CommandBuffer,
13705 _info_count: u32,
13706 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR<'_>,
13707 _pp_build_range_infos : * const * const AccelerationStructureBuildRangeInfoKHR,
13708 ) {
13709 panic!(concat!(
13710 "Unable to load ",
13711 stringify!(cmd_build_acceleration_structures_khr)
13712 ))
13713 }
13714 let cname = CStr::from_bytes_with_nul_unchecked(
13715 b"vkCmdBuildAccelerationStructuresKHR\0",
13716 );
13717 let val = _f(cname);
13718 if val.is_null() {
13719 cmd_build_acceleration_structures_khr
13720 } else {
13721 ::core::mem::transmute(val)
13722 }
13723 },
13724 cmd_build_acceleration_structures_indirect_khr: unsafe {
13725 unsafe extern "system" fn cmd_build_acceleration_structures_indirect_khr(
13726 _command_buffer: CommandBuffer,
13727 _info_count: u32,
13728 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR<'_>,
13729 _p_indirect_device_addresses: *const DeviceAddress,
13730 _p_indirect_strides: *const u32,
13731 _pp_max_primitive_counts: *const *const u32,
13732 ) {
13733 panic!(concat!(
13734 "Unable to load ",
13735 stringify!(cmd_build_acceleration_structures_indirect_khr)
13736 ))
13737 }
13738 let cname = CStr::from_bytes_with_nul_unchecked(
13739 b"vkCmdBuildAccelerationStructuresIndirectKHR\0",
13740 );
13741 let val = _f(cname);
13742 if val.is_null() {
13743 cmd_build_acceleration_structures_indirect_khr
13744 } else {
13745 ::core::mem::transmute(val)
13746 }
13747 },
13748 build_acceleration_structures_khr: unsafe {
13749 unsafe extern "system" fn build_acceleration_structures_khr(
13750 _device: crate::vk::Device,
13751 _deferred_operation: DeferredOperationKHR,
13752 _info_count: u32,
13753 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR<'_>,
13754 _pp_build_range_infos : * const * const AccelerationStructureBuildRangeInfoKHR,
13755 ) -> Result {
13756 panic!(concat!(
13757 "Unable to load ",
13758 stringify!(build_acceleration_structures_khr)
13759 ))
13760 }
13761 let cname = CStr::from_bytes_with_nul_unchecked(
13762 b"vkBuildAccelerationStructuresKHR\0",
13763 );
13764 let val = _f(cname);
13765 if val.is_null() {
13766 build_acceleration_structures_khr
13767 } else {
13768 ::core::mem::transmute(val)
13769 }
13770 },
13771 copy_acceleration_structure_khr: unsafe {
13772 unsafe extern "system" fn copy_acceleration_structure_khr(
13773 _device: crate::vk::Device,
13774 _deferred_operation: DeferredOperationKHR,
13775 _p_info: *const CopyAccelerationStructureInfoKHR<'_>,
13776 ) -> Result {
13777 panic!(concat!(
13778 "Unable to load ",
13779 stringify!(copy_acceleration_structure_khr)
13780 ))
13781 }
13782 let cname = CStr::from_bytes_with_nul_unchecked(
13783 b"vkCopyAccelerationStructureKHR\0",
13784 );
13785 let val = _f(cname);
13786 if val.is_null() {
13787 copy_acceleration_structure_khr
13788 } else {
13789 ::core::mem::transmute(val)
13790 }
13791 },
13792 copy_acceleration_structure_to_memory_khr: unsafe {
13793 unsafe extern "system" fn copy_acceleration_structure_to_memory_khr(
13794 _device: crate::vk::Device,
13795 _deferred_operation: DeferredOperationKHR,
13796 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR<'_>,
13797 ) -> Result {
13798 panic!(concat!(
13799 "Unable to load ",
13800 stringify!(copy_acceleration_structure_to_memory_khr)
13801 ))
13802 }
13803 let cname = CStr::from_bytes_with_nul_unchecked(
13804 b"vkCopyAccelerationStructureToMemoryKHR\0",
13805 );
13806 let val = _f(cname);
13807 if val.is_null() {
13808 copy_acceleration_structure_to_memory_khr
13809 } else {
13810 ::core::mem::transmute(val)
13811 }
13812 },
13813 copy_memory_to_acceleration_structure_khr: unsafe {
13814 unsafe extern "system" fn copy_memory_to_acceleration_structure_khr(
13815 _device: crate::vk::Device,
13816 _deferred_operation: DeferredOperationKHR,
13817 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR<'_>,
13818 ) -> Result {
13819 panic!(concat!(
13820 "Unable to load ",
13821 stringify!(copy_memory_to_acceleration_structure_khr)
13822 ))
13823 }
13824 let cname = CStr::from_bytes_with_nul_unchecked(
13825 b"vkCopyMemoryToAccelerationStructureKHR\0",
13826 );
13827 let val = _f(cname);
13828 if val.is_null() {
13829 copy_memory_to_acceleration_structure_khr
13830 } else {
13831 ::core::mem::transmute(val)
13832 }
13833 },
13834 write_acceleration_structures_properties_khr: unsafe {
13835 unsafe extern "system" fn write_acceleration_structures_properties_khr(
13836 _device: crate::vk::Device,
13837 _acceleration_structure_count: u32,
13838 _p_acceleration_structures: *const AccelerationStructureKHR,
13839 _query_type: QueryType,
13840 _data_size: usize,
13841 _p_data: *mut c_void,
13842 _stride: usize,
13843 ) -> Result {
13844 panic!(concat!(
13845 "Unable to load ",
13846 stringify!(write_acceleration_structures_properties_khr)
13847 ))
13848 }
13849 let cname = CStr::from_bytes_with_nul_unchecked(
13850 b"vkWriteAccelerationStructuresPropertiesKHR\0",
13851 );
13852 let val = _f(cname);
13853 if val.is_null() {
13854 write_acceleration_structures_properties_khr
13855 } else {
13856 ::core::mem::transmute(val)
13857 }
13858 },
13859 cmd_copy_acceleration_structure_khr: unsafe {
13860 unsafe extern "system" fn cmd_copy_acceleration_structure_khr(
13861 _command_buffer: CommandBuffer,
13862 _p_info: *const CopyAccelerationStructureInfoKHR<'_>,
13863 ) {
13864 panic!(concat!(
13865 "Unable to load ",
13866 stringify!(cmd_copy_acceleration_structure_khr)
13867 ))
13868 }
13869 let cname = CStr::from_bytes_with_nul_unchecked(
13870 b"vkCmdCopyAccelerationStructureKHR\0",
13871 );
13872 let val = _f(cname);
13873 if val.is_null() {
13874 cmd_copy_acceleration_structure_khr
13875 } else {
13876 ::core::mem::transmute(val)
13877 }
13878 },
13879 cmd_copy_acceleration_structure_to_memory_khr: unsafe {
13880 unsafe extern "system" fn cmd_copy_acceleration_structure_to_memory_khr(
13881 _command_buffer: CommandBuffer,
13882 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR<'_>,
13883 ) {
13884 panic!(concat!(
13885 "Unable to load ",
13886 stringify!(cmd_copy_acceleration_structure_to_memory_khr)
13887 ))
13888 }
13889 let cname = CStr::from_bytes_with_nul_unchecked(
13890 b"vkCmdCopyAccelerationStructureToMemoryKHR\0",
13891 );
13892 let val = _f(cname);
13893 if val.is_null() {
13894 cmd_copy_acceleration_structure_to_memory_khr
13895 } else {
13896 ::core::mem::transmute(val)
13897 }
13898 },
13899 cmd_copy_memory_to_acceleration_structure_khr: unsafe {
13900 unsafe extern "system" fn cmd_copy_memory_to_acceleration_structure_khr(
13901 _command_buffer: CommandBuffer,
13902 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR<'_>,
13903 ) {
13904 panic!(concat!(
13905 "Unable to load ",
13906 stringify!(cmd_copy_memory_to_acceleration_structure_khr)
13907 ))
13908 }
13909 let cname = CStr::from_bytes_with_nul_unchecked(
13910 b"vkCmdCopyMemoryToAccelerationStructureKHR\0",
13911 );
13912 let val = _f(cname);
13913 if val.is_null() {
13914 cmd_copy_memory_to_acceleration_structure_khr
13915 } else {
13916 ::core::mem::transmute(val)
13917 }
13918 },
13919 get_acceleration_structure_device_address_khr: unsafe {
13920 unsafe extern "system" fn get_acceleration_structure_device_address_khr(
13921 _device: crate::vk::Device,
13922 _p_info: *const AccelerationStructureDeviceAddressInfoKHR<'_>,
13923 ) -> DeviceAddress {
13924 panic!(concat!(
13925 "Unable to load ",
13926 stringify!(get_acceleration_structure_device_address_khr)
13927 ))
13928 }
13929 let cname = CStr::from_bytes_with_nul_unchecked(
13930 b"vkGetAccelerationStructureDeviceAddressKHR\0",
13931 );
13932 let val = _f(cname);
13933 if val.is_null() {
13934 get_acceleration_structure_device_address_khr
13935 } else {
13936 ::core::mem::transmute(val)
13937 }
13938 },
13939 cmd_write_acceleration_structures_properties_khr: unsafe {
13940 unsafe extern "system" fn cmd_write_acceleration_structures_properties_khr(
13941 _command_buffer: CommandBuffer,
13942 _acceleration_structure_count: u32,
13943 _p_acceleration_structures: *const AccelerationStructureKHR,
13944 _query_type: QueryType,
13945 _query_pool: QueryPool,
13946 _first_query: u32,
13947 ) {
13948 panic!(concat!(
13949 "Unable to load ",
13950 stringify!(cmd_write_acceleration_structures_properties_khr)
13951 ))
13952 }
13953 let cname = CStr::from_bytes_with_nul_unchecked(
13954 b"vkCmdWriteAccelerationStructuresPropertiesKHR\0",
13955 );
13956 let val = _f(cname);
13957 if val.is_null() {
13958 cmd_write_acceleration_structures_properties_khr
13959 } else {
13960 ::core::mem::transmute(val)
13961 }
13962 },
13963 get_device_acceleration_structure_compatibility_khr: unsafe {
13964 unsafe extern "system" fn get_device_acceleration_structure_compatibility_khr(
13965 _device: crate::vk::Device,
13966 _p_version_info: *const AccelerationStructureVersionInfoKHR<'_>,
13967 _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
13968 ) {
13969 panic!(concat!(
13970 "Unable to load ",
13971 stringify!(get_device_acceleration_structure_compatibility_khr)
13972 ))
13973 }
13974 let cname = CStr::from_bytes_with_nul_unchecked(
13975 b"vkGetDeviceAccelerationStructureCompatibilityKHR\0",
13976 );
13977 let val = _f(cname);
13978 if val.is_null() {
13979 get_device_acceleration_structure_compatibility_khr
13980 } else {
13981 ::core::mem::transmute(val)
13982 }
13983 },
13984 get_acceleration_structure_build_sizes_khr: unsafe {
13985 unsafe extern "system" fn get_acceleration_structure_build_sizes_khr(
13986 _device: crate::vk::Device,
13987 _build_type: AccelerationStructureBuildTypeKHR,
13988 _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR<'_>,
13989 _p_max_primitive_counts: *const u32,
13990 _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR<'_>,
13991 ) {
13992 panic!(concat!(
13993 "Unable to load ",
13994 stringify!(get_acceleration_structure_build_sizes_khr)
13995 ))
13996 }
13997 let cname = CStr::from_bytes_with_nul_unchecked(
13998 b"vkGetAccelerationStructureBuildSizesKHR\0",
13999 );
14000 let val = _f(cname);
14001 if val.is_null() {
14002 get_acceleration_structure_build_sizes_khr
14003 } else {
14004 ::core::mem::transmute(val)
14005 }
14006 },
14007 }
14008 }
14009 }
14010 }
14011 #[doc = "VK_KHR_ray_tracing_pipeline"]
14012 pub mod ray_tracing_pipeline {
14013 use super::super::*;
14014 pub use {
14015 crate::vk::KHR_RAY_TRACING_PIPELINE_NAME as NAME,
14016 crate::vk::KHR_RAY_TRACING_PIPELINE_SPEC_VERSION as SPEC_VERSION,
14017 };
14018 #[doc = "VK_KHR_ray_tracing_pipeline device-level functions"]
14019 #[derive(Clone)]
14020 pub struct Device {
14021 pub(crate) fp: DeviceFn,
14022 pub(crate) handle: crate::vk::Device,
14023 }
14024 impl Device {
14025 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14026 let handle = device.handle();
14027 let fp = DeviceFn::load(|name| unsafe {
14028 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14029 });
14030 Self { handle, fp }
14031 }
14032 #[inline]
14033 pub fn fp(&self) -> &DeviceFn {
14034 &self.fp
14035 }
14036 #[inline]
14037 pub fn device(&self) -> crate::vk::Device {
14038 self.handle
14039 }
14040 }
14041 #[derive(Clone)]
14042 #[doc = "Raw VK_KHR_ray_tracing_pipeline device-level function pointers"]
14043 pub struct DeviceFn {
14044 pub cmd_trace_rays_khr: PFN_vkCmdTraceRaysKHR,
14045 pub create_ray_tracing_pipelines_khr: PFN_vkCreateRayTracingPipelinesKHR,
14046 pub get_ray_tracing_shader_group_handles_khr: PFN_vkGetRayTracingShaderGroupHandlesKHR,
14047 pub get_ray_tracing_capture_replay_shader_group_handles_khr:
14048 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
14049 pub cmd_trace_rays_indirect_khr: PFN_vkCmdTraceRaysIndirectKHR,
14050 pub get_ray_tracing_shader_group_stack_size_khr:
14051 PFN_vkGetRayTracingShaderGroupStackSizeKHR,
14052 pub cmd_set_ray_tracing_pipeline_stack_size_khr:
14053 PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
14054 }
14055 unsafe impl Send for DeviceFn {}
14056 unsafe impl Sync for DeviceFn {}
14057 impl DeviceFn {
14058 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14059 Self::load_erased(&mut f)
14060 }
14061 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14062 Self {
14063 cmd_trace_rays_khr: unsafe {
14064 unsafe extern "system" fn cmd_trace_rays_khr(
14065 _command_buffer: CommandBuffer,
14066 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14067 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14068 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14069 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14070 _width: u32,
14071 _height: u32,
14072 _depth: u32,
14073 ) {
14074 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr)))
14075 }
14076 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysKHR\0");
14077 let val = _f(cname);
14078 if val.is_null() {
14079 cmd_trace_rays_khr
14080 } else {
14081 ::core::mem::transmute(val)
14082 }
14083 },
14084 create_ray_tracing_pipelines_khr: unsafe {
14085 unsafe extern "system" fn create_ray_tracing_pipelines_khr(
14086 _device: crate::vk::Device,
14087 _deferred_operation: DeferredOperationKHR,
14088 _pipeline_cache: PipelineCache,
14089 _create_info_count: u32,
14090 _p_create_infos: *const RayTracingPipelineCreateInfoKHR<'_>,
14091 _p_allocator: *const AllocationCallbacks<'_>,
14092 _p_pipelines: *mut Pipeline,
14093 ) -> Result {
14094 panic!(concat!(
14095 "Unable to load ",
14096 stringify!(create_ray_tracing_pipelines_khr)
14097 ))
14098 }
14099 let cname = CStr::from_bytes_with_nul_unchecked(
14100 b"vkCreateRayTracingPipelinesKHR\0",
14101 );
14102 let val = _f(cname);
14103 if val.is_null() {
14104 create_ray_tracing_pipelines_khr
14105 } else {
14106 ::core::mem::transmute(val)
14107 }
14108 },
14109 get_ray_tracing_shader_group_handles_khr: unsafe {
14110 unsafe extern "system" fn get_ray_tracing_shader_group_handles_khr(
14111 _device: crate::vk::Device,
14112 _pipeline: Pipeline,
14113 _first_group: u32,
14114 _group_count: u32,
14115 _data_size: usize,
14116 _p_data: *mut c_void,
14117 ) -> Result {
14118 panic!(concat!(
14119 "Unable to load ",
14120 stringify!(get_ray_tracing_shader_group_handles_khr)
14121 ))
14122 }
14123 let cname = CStr::from_bytes_with_nul_unchecked(
14124 b"vkGetRayTracingShaderGroupHandlesKHR\0",
14125 );
14126 let val = _f(cname);
14127 if val.is_null() {
14128 get_ray_tracing_shader_group_handles_khr
14129 } else {
14130 ::core::mem::transmute(val)
14131 }
14132 },
14133 get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe {
14134 unsafe extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr(
14135 _device: crate::vk::Device,
14136 _pipeline: Pipeline,
14137 _first_group: u32,
14138 _group_count: u32,
14139 _data_size: usize,
14140 _p_data: *mut c_void,
14141 ) -> Result {
14142 panic!(concat!(
14143 "Unable to load ",
14144 stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr)
14145 ))
14146 }
14147 let cname = CStr::from_bytes_with_nul_unchecked(
14148 b"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\0",
14149 );
14150 let val = _f(cname);
14151 if val.is_null() {
14152 get_ray_tracing_capture_replay_shader_group_handles_khr
14153 } else {
14154 ::core::mem::transmute(val)
14155 }
14156 },
14157 cmd_trace_rays_indirect_khr: unsafe {
14158 unsafe extern "system" fn cmd_trace_rays_indirect_khr(
14159 _command_buffer: CommandBuffer,
14160 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14161 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14162 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14163 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
14164 _indirect_device_address: DeviceAddress,
14165 ) {
14166 panic!(concat!(
14167 "Unable to load ",
14168 stringify!(cmd_trace_rays_indirect_khr)
14169 ))
14170 }
14171 let cname =
14172 CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirectKHR\0");
14173 let val = _f(cname);
14174 if val.is_null() {
14175 cmd_trace_rays_indirect_khr
14176 } else {
14177 ::core::mem::transmute(val)
14178 }
14179 },
14180 get_ray_tracing_shader_group_stack_size_khr: unsafe {
14181 unsafe extern "system" fn get_ray_tracing_shader_group_stack_size_khr(
14182 _device: crate::vk::Device,
14183 _pipeline: Pipeline,
14184 _group: u32,
14185 _group_shader: ShaderGroupShaderKHR,
14186 ) -> DeviceSize {
14187 panic!(concat!(
14188 "Unable to load ",
14189 stringify!(get_ray_tracing_shader_group_stack_size_khr)
14190 ))
14191 }
14192 let cname = CStr::from_bytes_with_nul_unchecked(
14193 b"vkGetRayTracingShaderGroupStackSizeKHR\0",
14194 );
14195 let val = _f(cname);
14196 if val.is_null() {
14197 get_ray_tracing_shader_group_stack_size_khr
14198 } else {
14199 ::core::mem::transmute(val)
14200 }
14201 },
14202 cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe {
14203 unsafe extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr(
14204 _command_buffer: CommandBuffer,
14205 _pipeline_stack_size: u32,
14206 ) {
14207 panic!(concat!(
14208 "Unable to load ",
14209 stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr)
14210 ))
14211 }
14212 let cname = CStr::from_bytes_with_nul_unchecked(
14213 b"vkCmdSetRayTracingPipelineStackSizeKHR\0",
14214 );
14215 let val = _f(cname);
14216 if val.is_null() {
14217 cmd_set_ray_tracing_pipeline_stack_size_khr
14218 } else {
14219 ::core::mem::transmute(val)
14220 }
14221 },
14222 }
14223 }
14224 }
14225 }
14226 #[doc = "VK_KHR_ray_query"]
14227 pub mod ray_query {
14228 use super::super::*;
14229 pub use {
14230 crate::vk::KHR_RAY_QUERY_NAME as NAME,
14231 crate::vk::KHR_RAY_QUERY_SPEC_VERSION as SPEC_VERSION,
14232 };
14233 }
14234 #[doc = "VK_KHR_sampler_ycbcr_conversion"]
14235 pub mod sampler_ycbcr_conversion {
14236 use super::super::*;
14237 pub use {
14238 crate::vk::KHR_SAMPLER_YCBCR_CONVERSION_NAME as NAME,
14239 crate::vk::KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION as SPEC_VERSION,
14240 };
14241 #[doc = "VK_KHR_sampler_ycbcr_conversion device-level functions"]
14242 #[derive(Clone)]
14243 pub struct Device {
14244 pub(crate) fp: DeviceFn,
14245 pub(crate) handle: crate::vk::Device,
14246 }
14247 impl Device {
14248 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14249 let handle = device.handle();
14250 let fp = DeviceFn::load(|name| unsafe {
14251 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14252 });
14253 Self { handle, fp }
14254 }
14255 #[inline]
14256 pub fn fp(&self) -> &DeviceFn {
14257 &self.fp
14258 }
14259 #[inline]
14260 pub fn device(&self) -> crate::vk::Device {
14261 self.handle
14262 }
14263 }
14264 #[derive(Clone)]
14265 #[doc = "Raw VK_KHR_sampler_ycbcr_conversion device-level function pointers"]
14266 pub struct DeviceFn {
14267 pub create_sampler_ycbcr_conversion_khr: PFN_vkCreateSamplerYcbcrConversion,
14268 pub destroy_sampler_ycbcr_conversion_khr: PFN_vkDestroySamplerYcbcrConversion,
14269 }
14270 unsafe impl Send for DeviceFn {}
14271 unsafe impl Sync for DeviceFn {}
14272 impl DeviceFn {
14273 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14274 Self::load_erased(&mut f)
14275 }
14276 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14277 Self {
14278 create_sampler_ycbcr_conversion_khr: unsafe {
14279 unsafe extern "system" fn create_sampler_ycbcr_conversion_khr(
14280 _device: crate::vk::Device,
14281 _p_create_info: *const SamplerYcbcrConversionCreateInfo<'_>,
14282 _p_allocator: *const AllocationCallbacks<'_>,
14283 _p_ycbcr_conversion: *mut SamplerYcbcrConversion,
14284 ) -> Result {
14285 panic!(concat!(
14286 "Unable to load ",
14287 stringify!(create_sampler_ycbcr_conversion_khr)
14288 ))
14289 }
14290 let cname = CStr::from_bytes_with_nul_unchecked(
14291 b"vkCreateSamplerYcbcrConversionKHR\0",
14292 );
14293 let val = _f(cname);
14294 if val.is_null() {
14295 create_sampler_ycbcr_conversion_khr
14296 } else {
14297 ::core::mem::transmute(val)
14298 }
14299 },
14300 destroy_sampler_ycbcr_conversion_khr: unsafe {
14301 unsafe extern "system" fn destroy_sampler_ycbcr_conversion_khr(
14302 _device: crate::vk::Device,
14303 _ycbcr_conversion: SamplerYcbcrConversion,
14304 _p_allocator: *const AllocationCallbacks<'_>,
14305 ) {
14306 panic!(concat!(
14307 "Unable to load ",
14308 stringify!(destroy_sampler_ycbcr_conversion_khr)
14309 ))
14310 }
14311 let cname = CStr::from_bytes_with_nul_unchecked(
14312 b"vkDestroySamplerYcbcrConversionKHR\0",
14313 );
14314 let val = _f(cname);
14315 if val.is_null() {
14316 destroy_sampler_ycbcr_conversion_khr
14317 } else {
14318 ::core::mem::transmute(val)
14319 }
14320 },
14321 }
14322 }
14323 }
14324 }
14325 #[doc = "VK_KHR_bind_memory2"]
14326 pub mod bind_memory2 {
14327 use super::super::*;
14328 pub use {
14329 crate::vk::KHR_BIND_MEMORY2_NAME as NAME,
14330 crate::vk::KHR_BIND_MEMORY2_SPEC_VERSION as SPEC_VERSION,
14331 };
14332 #[doc = "VK_KHR_bind_memory2 device-level functions"]
14333 #[derive(Clone)]
14334 pub struct Device {
14335 pub(crate) fp: DeviceFn,
14336 pub(crate) handle: crate::vk::Device,
14337 }
14338 impl Device {
14339 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14340 let handle = device.handle();
14341 let fp = DeviceFn::load(|name| unsafe {
14342 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14343 });
14344 Self { handle, fp }
14345 }
14346 #[inline]
14347 pub fn fp(&self) -> &DeviceFn {
14348 &self.fp
14349 }
14350 #[inline]
14351 pub fn device(&self) -> crate::vk::Device {
14352 self.handle
14353 }
14354 }
14355 #[derive(Clone)]
14356 #[doc = "Raw VK_KHR_bind_memory2 device-level function pointers"]
14357 pub struct DeviceFn {
14358 pub bind_buffer_memory2_khr: PFN_vkBindBufferMemory2,
14359 pub bind_image_memory2_khr: PFN_vkBindImageMemory2,
14360 }
14361 unsafe impl Send for DeviceFn {}
14362 unsafe impl Sync for DeviceFn {}
14363 impl DeviceFn {
14364 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14365 Self::load_erased(&mut f)
14366 }
14367 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14368 Self {
14369 bind_buffer_memory2_khr: unsafe {
14370 unsafe extern "system" fn bind_buffer_memory2_khr(
14371 _device: crate::vk::Device,
14372 _bind_info_count: u32,
14373 _p_bind_infos: *const BindBufferMemoryInfo<'_>,
14374 ) -> Result {
14375 panic!(concat!(
14376 "Unable to load ",
14377 stringify!(bind_buffer_memory2_khr)
14378 ))
14379 }
14380 let cname =
14381 CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2KHR\0");
14382 let val = _f(cname);
14383 if val.is_null() {
14384 bind_buffer_memory2_khr
14385 } else {
14386 ::core::mem::transmute(val)
14387 }
14388 },
14389 bind_image_memory2_khr: unsafe {
14390 unsafe extern "system" fn bind_image_memory2_khr(
14391 _device: crate::vk::Device,
14392 _bind_info_count: u32,
14393 _p_bind_infos: *const BindImageMemoryInfo<'_>,
14394 ) -> Result {
14395 panic!(concat!(
14396 "Unable to load ",
14397 stringify!(bind_image_memory2_khr)
14398 ))
14399 }
14400 let cname = CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2KHR\0");
14401 let val = _f(cname);
14402 if val.is_null() {
14403 bind_image_memory2_khr
14404 } else {
14405 ::core::mem::transmute(val)
14406 }
14407 },
14408 }
14409 }
14410 }
14411 }
14412 #[doc = "VK_KHR_portability_subset"]
14413 pub mod portability_subset {
14414 use super::super::*;
14415 pub use {
14416 crate::vk::KHR_PORTABILITY_SUBSET_NAME as NAME,
14417 crate::vk::KHR_PORTABILITY_SUBSET_SPEC_VERSION as SPEC_VERSION,
14418 };
14419 }
14420 #[doc = "VK_KHR_maintenance3"]
14421 pub mod maintenance3 {
14422 use super::super::*;
14423 pub use {
14424 crate::vk::KHR_MAINTENANCE3_NAME as NAME,
14425 crate::vk::KHR_MAINTENANCE3_SPEC_VERSION as SPEC_VERSION,
14426 };
14427 #[doc = "VK_KHR_maintenance3 device-level functions"]
14428 #[derive(Clone)]
14429 pub struct Device {
14430 pub(crate) fp: DeviceFn,
14431 pub(crate) handle: crate::vk::Device,
14432 }
14433 impl Device {
14434 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14435 let handle = device.handle();
14436 let fp = DeviceFn::load(|name| unsafe {
14437 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14438 });
14439 Self { handle, fp }
14440 }
14441 #[inline]
14442 pub fn fp(&self) -> &DeviceFn {
14443 &self.fp
14444 }
14445 #[inline]
14446 pub fn device(&self) -> crate::vk::Device {
14447 self.handle
14448 }
14449 }
14450 #[derive(Clone)]
14451 #[doc = "Raw VK_KHR_maintenance3 device-level function pointers"]
14452 pub struct DeviceFn {
14453 pub get_descriptor_set_layout_support_khr: PFN_vkGetDescriptorSetLayoutSupport,
14454 }
14455 unsafe impl Send for DeviceFn {}
14456 unsafe impl Sync for DeviceFn {}
14457 impl DeviceFn {
14458 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14459 Self::load_erased(&mut f)
14460 }
14461 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14462 Self {
14463 get_descriptor_set_layout_support_khr: unsafe {
14464 unsafe extern "system" fn get_descriptor_set_layout_support_khr(
14465 _device: crate::vk::Device,
14466 _p_create_info: *const DescriptorSetLayoutCreateInfo<'_>,
14467 _p_support: *mut DescriptorSetLayoutSupport<'_>,
14468 ) {
14469 panic!(concat!(
14470 "Unable to load ",
14471 stringify!(get_descriptor_set_layout_support_khr)
14472 ))
14473 }
14474 let cname = CStr::from_bytes_with_nul_unchecked(
14475 b"vkGetDescriptorSetLayoutSupportKHR\0",
14476 );
14477 let val = _f(cname);
14478 if val.is_null() {
14479 get_descriptor_set_layout_support_khr
14480 } else {
14481 ::core::mem::transmute(val)
14482 }
14483 },
14484 }
14485 }
14486 }
14487 }
14488 #[doc = "VK_KHR_draw_indirect_count"]
14489 pub mod draw_indirect_count {
14490 use super::super::*;
14491 pub use {
14492 crate::vk::KHR_DRAW_INDIRECT_COUNT_NAME as NAME,
14493 crate::vk::KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION as SPEC_VERSION,
14494 };
14495 #[doc = "VK_KHR_draw_indirect_count device-level functions"]
14496 #[derive(Clone)]
14497 pub struct Device {
14498 pub(crate) fp: DeviceFn,
14499 pub(crate) handle: crate::vk::Device,
14500 }
14501 impl Device {
14502 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14503 let handle = device.handle();
14504 let fp = DeviceFn::load(|name| unsafe {
14505 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14506 });
14507 Self { handle, fp }
14508 }
14509 #[inline]
14510 pub fn fp(&self) -> &DeviceFn {
14511 &self.fp
14512 }
14513 #[inline]
14514 pub fn device(&self) -> crate::vk::Device {
14515 self.handle
14516 }
14517 }
14518 #[derive(Clone)]
14519 #[doc = "Raw VK_KHR_draw_indirect_count device-level function pointers"]
14520 pub struct DeviceFn {
14521 pub cmd_draw_indirect_count_khr: PFN_vkCmdDrawIndirectCount,
14522 pub cmd_draw_indexed_indirect_count_khr: PFN_vkCmdDrawIndexedIndirectCount,
14523 }
14524 unsafe impl Send for DeviceFn {}
14525 unsafe impl Sync for DeviceFn {}
14526 impl DeviceFn {
14527 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14528 Self::load_erased(&mut f)
14529 }
14530 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14531 Self {
14532 cmd_draw_indirect_count_khr: unsafe {
14533 unsafe extern "system" fn cmd_draw_indirect_count_khr(
14534 _command_buffer: CommandBuffer,
14535 _buffer: Buffer,
14536 _offset: DeviceSize,
14537 _count_buffer: Buffer,
14538 _count_buffer_offset: DeviceSize,
14539 _max_draw_count: u32,
14540 _stride: u32,
14541 ) {
14542 panic!(concat!(
14543 "Unable to load ",
14544 stringify!(cmd_draw_indirect_count_khr)
14545 ))
14546 }
14547 let cname =
14548 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountKHR\0");
14549 let val = _f(cname);
14550 if val.is_null() {
14551 cmd_draw_indirect_count_khr
14552 } else {
14553 ::core::mem::transmute(val)
14554 }
14555 },
14556 cmd_draw_indexed_indirect_count_khr: unsafe {
14557 unsafe extern "system" fn cmd_draw_indexed_indirect_count_khr(
14558 _command_buffer: CommandBuffer,
14559 _buffer: Buffer,
14560 _offset: DeviceSize,
14561 _count_buffer: Buffer,
14562 _count_buffer_offset: DeviceSize,
14563 _max_draw_count: u32,
14564 _stride: u32,
14565 ) {
14566 panic!(concat!(
14567 "Unable to load ",
14568 stringify!(cmd_draw_indexed_indirect_count_khr)
14569 ))
14570 }
14571 let cname = CStr::from_bytes_with_nul_unchecked(
14572 b"vkCmdDrawIndexedIndirectCountKHR\0",
14573 );
14574 let val = _f(cname);
14575 if val.is_null() {
14576 cmd_draw_indexed_indirect_count_khr
14577 } else {
14578 ::core::mem::transmute(val)
14579 }
14580 },
14581 }
14582 }
14583 }
14584 }
14585 #[doc = "VK_KHR_shader_subgroup_extended_types"]
14586 pub mod shader_subgroup_extended_types {
14587 use super::super::*;
14588 pub use {
14589 crate::vk::KHR_SHADER_SUBGROUP_EXTENDED_TYPES_NAME as NAME,
14590 crate::vk::KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION as SPEC_VERSION,
14591 };
14592 }
14593 #[doc = "VK_KHR_8bit_storage"]
14594 pub mod _8bit_storage {
14595 use super::super::*;
14596 pub use {
14597 crate::vk::KHR_8BIT_STORAGE_NAME as NAME,
14598 crate::vk::KHR_8BIT_STORAGE_SPEC_VERSION as SPEC_VERSION,
14599 };
14600 }
14601 #[doc = "VK_KHR_shader_atomic_int64"]
14602 pub mod shader_atomic_int64 {
14603 use super::super::*;
14604 pub use {
14605 crate::vk::KHR_SHADER_ATOMIC_INT64_NAME as NAME,
14606 crate::vk::KHR_SHADER_ATOMIC_INT64_SPEC_VERSION as SPEC_VERSION,
14607 };
14608 }
14609 #[doc = "VK_KHR_shader_clock"]
14610 pub mod shader_clock {
14611 use super::super::*;
14612 pub use {
14613 crate::vk::KHR_SHADER_CLOCK_NAME as NAME,
14614 crate::vk::KHR_SHADER_CLOCK_SPEC_VERSION as SPEC_VERSION,
14615 };
14616 }
14617 #[doc = "VK_KHR_video_decode_h265"]
14618 pub mod video_decode_h265 {
14619 use super::super::*;
14620 pub use {
14621 crate::vk::KHR_VIDEO_DECODE_H265_NAME as NAME,
14622 crate::vk::KHR_VIDEO_DECODE_H265_SPEC_VERSION as SPEC_VERSION,
14623 };
14624 }
14625 #[doc = "VK_KHR_global_priority"]
14626 pub mod global_priority {
14627 use super::super::*;
14628 pub use {
14629 crate::vk::KHR_GLOBAL_PRIORITY_NAME as NAME,
14630 crate::vk::KHR_GLOBAL_PRIORITY_SPEC_VERSION as SPEC_VERSION,
14631 };
14632 }
14633 #[doc = "VK_KHR_driver_properties"]
14634 pub mod driver_properties {
14635 use super::super::*;
14636 pub use {
14637 crate::vk::KHR_DRIVER_PROPERTIES_NAME as NAME,
14638 crate::vk::KHR_DRIVER_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
14639 };
14640 }
14641 #[doc = "VK_KHR_shader_float_controls"]
14642 pub mod shader_float_controls {
14643 use super::super::*;
14644 pub use {
14645 crate::vk::KHR_SHADER_FLOAT_CONTROLS_NAME as NAME,
14646 crate::vk::KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION as SPEC_VERSION,
14647 };
14648 }
14649 #[doc = "VK_KHR_depth_stencil_resolve"]
14650 pub mod depth_stencil_resolve {
14651 use super::super::*;
14652 pub use {
14653 crate::vk::KHR_DEPTH_STENCIL_RESOLVE_NAME as NAME,
14654 crate::vk::KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION as SPEC_VERSION,
14655 };
14656 }
14657 #[doc = "VK_KHR_swapchain_mutable_format"]
14658 pub mod swapchain_mutable_format {
14659 use super::super::*;
14660 pub use {
14661 crate::vk::KHR_SWAPCHAIN_MUTABLE_FORMAT_NAME as NAME,
14662 crate::vk::KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION as SPEC_VERSION,
14663 };
14664 }
14665 #[doc = "VK_KHR_timeline_semaphore"]
14666 pub mod timeline_semaphore {
14667 use super::super::*;
14668 pub use {
14669 crate::vk::KHR_TIMELINE_SEMAPHORE_NAME as NAME,
14670 crate::vk::KHR_TIMELINE_SEMAPHORE_SPEC_VERSION as SPEC_VERSION,
14671 };
14672 #[doc = "VK_KHR_timeline_semaphore device-level functions"]
14673 #[derive(Clone)]
14674 pub struct Device {
14675 pub(crate) fp: DeviceFn,
14676 pub(crate) handle: crate::vk::Device,
14677 }
14678 impl Device {
14679 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14680 let handle = device.handle();
14681 let fp = DeviceFn::load(|name| unsafe {
14682 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14683 });
14684 Self { handle, fp }
14685 }
14686 #[inline]
14687 pub fn fp(&self) -> &DeviceFn {
14688 &self.fp
14689 }
14690 #[inline]
14691 pub fn device(&self) -> crate::vk::Device {
14692 self.handle
14693 }
14694 }
14695 #[derive(Clone)]
14696 #[doc = "Raw VK_KHR_timeline_semaphore device-level function pointers"]
14697 pub struct DeviceFn {
14698 pub get_semaphore_counter_value_khr: PFN_vkGetSemaphoreCounterValue,
14699 pub wait_semaphores_khr: PFN_vkWaitSemaphores,
14700 pub signal_semaphore_khr: PFN_vkSignalSemaphore,
14701 }
14702 unsafe impl Send for DeviceFn {}
14703 unsafe impl Sync for DeviceFn {}
14704 impl DeviceFn {
14705 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14706 Self::load_erased(&mut f)
14707 }
14708 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14709 Self {
14710 get_semaphore_counter_value_khr: unsafe {
14711 unsafe extern "system" fn get_semaphore_counter_value_khr(
14712 _device: crate::vk::Device,
14713 _semaphore: Semaphore,
14714 _p_value: *mut u64,
14715 ) -> Result {
14716 panic!(concat!(
14717 "Unable to load ",
14718 stringify!(get_semaphore_counter_value_khr)
14719 ))
14720 }
14721 let cname =
14722 CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreCounterValueKHR\0");
14723 let val = _f(cname);
14724 if val.is_null() {
14725 get_semaphore_counter_value_khr
14726 } else {
14727 ::core::mem::transmute(val)
14728 }
14729 },
14730 wait_semaphores_khr: unsafe {
14731 unsafe extern "system" fn wait_semaphores_khr(
14732 _device: crate::vk::Device,
14733 _p_wait_info: *const SemaphoreWaitInfo<'_>,
14734 _timeout: u64,
14735 ) -> Result {
14736 panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr)))
14737 }
14738 let cname = CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphoresKHR\0");
14739 let val = _f(cname);
14740 if val.is_null() {
14741 wait_semaphores_khr
14742 } else {
14743 ::core::mem::transmute(val)
14744 }
14745 },
14746 signal_semaphore_khr: unsafe {
14747 unsafe extern "system" fn signal_semaphore_khr(
14748 _device: crate::vk::Device,
14749 _p_signal_info: *const SemaphoreSignalInfo<'_>,
14750 ) -> Result {
14751 panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr)))
14752 }
14753 let cname = CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphoreKHR\0");
14754 let val = _f(cname);
14755 if val.is_null() {
14756 signal_semaphore_khr
14757 } else {
14758 ::core::mem::transmute(val)
14759 }
14760 },
14761 }
14762 }
14763 }
14764 }
14765 #[doc = "VK_KHR_vulkan_memory_model"]
14766 pub mod vulkan_memory_model {
14767 use super::super::*;
14768 pub use {
14769 crate::vk::KHR_VULKAN_MEMORY_MODEL_NAME as NAME,
14770 crate::vk::KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION as SPEC_VERSION,
14771 };
14772 }
14773 #[doc = "VK_KHR_shader_terminate_invocation"]
14774 pub mod shader_terminate_invocation {
14775 use super::super::*;
14776 pub use {
14777 crate::vk::KHR_SHADER_TERMINATE_INVOCATION_NAME as NAME,
14778 crate::vk::KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION as SPEC_VERSION,
14779 };
14780 }
14781 #[doc = "VK_KHR_fragment_shading_rate"]
14782 pub mod fragment_shading_rate {
14783 use super::super::*;
14784 pub use {
14785 crate::vk::KHR_FRAGMENT_SHADING_RATE_NAME as NAME,
14786 crate::vk::KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION as SPEC_VERSION,
14787 };
14788 #[doc = "VK_KHR_fragment_shading_rate instance-level functions"]
14789 #[derive(Clone)]
14790 pub struct Instance {
14791 pub(crate) fp: InstanceFn,
14792 pub(crate) handle: crate::vk::Instance,
14793 }
14794 impl Instance {
14795 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
14796 let handle = instance.handle();
14797 let fp = InstanceFn::load(|name| unsafe {
14798 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
14799 });
14800 Self { handle, fp }
14801 }
14802 #[inline]
14803 pub fn fp(&self) -> &InstanceFn {
14804 &self.fp
14805 }
14806 #[inline]
14807 pub fn instance(&self) -> crate::vk::Instance {
14808 self.handle
14809 }
14810 }
14811 #[derive(Clone)]
14812 #[doc = "Raw VK_KHR_fragment_shading_rate instance-level function pointers"]
14813 pub struct InstanceFn {
14814 pub get_physical_device_fragment_shading_rates_khr:
14815 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR,
14816 }
14817 unsafe impl Send for InstanceFn {}
14818 unsafe impl Sync for InstanceFn {}
14819 impl InstanceFn {
14820 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14821 Self::load_erased(&mut f)
14822 }
14823 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14824 Self {
14825 get_physical_device_fragment_shading_rates_khr: unsafe {
14826 unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr(
14827 _physical_device: PhysicalDevice,
14828 _p_fragment_shading_rate_count: *mut u32,
14829 _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR<
14830 '_,
14831 >,
14832 ) -> Result {
14833 panic!(concat!(
14834 "Unable to load ",
14835 stringify!(get_physical_device_fragment_shading_rates_khr)
14836 ))
14837 }
14838 let cname = CStr::from_bytes_with_nul_unchecked(
14839 b"vkGetPhysicalDeviceFragmentShadingRatesKHR\0",
14840 );
14841 let val = _f(cname);
14842 if val.is_null() {
14843 get_physical_device_fragment_shading_rates_khr
14844 } else {
14845 ::core::mem::transmute(val)
14846 }
14847 },
14848 }
14849 }
14850 }
14851 #[doc = "VK_KHR_fragment_shading_rate device-level functions"]
14852 #[derive(Clone)]
14853 pub struct Device {
14854 pub(crate) fp: DeviceFn,
14855 pub(crate) handle: crate::vk::Device,
14856 }
14857 impl Device {
14858 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14859 let handle = device.handle();
14860 let fp = DeviceFn::load(|name| unsafe {
14861 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14862 });
14863 Self { handle, fp }
14864 }
14865 #[inline]
14866 pub fn fp(&self) -> &DeviceFn {
14867 &self.fp
14868 }
14869 #[inline]
14870 pub fn device(&self) -> crate::vk::Device {
14871 self.handle
14872 }
14873 }
14874 #[derive(Clone)]
14875 #[doc = "Raw VK_KHR_fragment_shading_rate device-level function pointers"]
14876 pub struct DeviceFn {
14877 pub cmd_set_fragment_shading_rate_khr: PFN_vkCmdSetFragmentShadingRateKHR,
14878 }
14879 unsafe impl Send for DeviceFn {}
14880 unsafe impl Sync for DeviceFn {}
14881 impl DeviceFn {
14882 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14883 Self::load_erased(&mut f)
14884 }
14885 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14886 Self {
14887 cmd_set_fragment_shading_rate_khr: unsafe {
14888 unsafe extern "system" fn cmd_set_fragment_shading_rate_khr(
14889 _command_buffer: CommandBuffer,
14890 _p_fragment_size: *const Extent2D,
14891 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
14892 ) {
14893 panic!(concat!(
14894 "Unable to load ",
14895 stringify!(cmd_set_fragment_shading_rate_khr)
14896 ))
14897 }
14898 let cname = CStr::from_bytes_with_nul_unchecked(
14899 b"vkCmdSetFragmentShadingRateKHR\0",
14900 );
14901 let val = _f(cname);
14902 if val.is_null() {
14903 cmd_set_fragment_shading_rate_khr
14904 } else {
14905 ::core::mem::transmute(val)
14906 }
14907 },
14908 }
14909 }
14910 }
14911 }
14912 #[doc = "VK_KHR_dynamic_rendering_local_read"]
14913 pub mod dynamic_rendering_local_read {
14914 use super::super::*;
14915 pub use {
14916 crate::vk::KHR_DYNAMIC_RENDERING_LOCAL_READ_NAME as NAME,
14917 crate::vk::KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION as SPEC_VERSION,
14918 };
14919 #[doc = "VK_KHR_dynamic_rendering_local_read device-level functions"]
14920 #[derive(Clone)]
14921 pub struct Device {
14922 pub(crate) fp: DeviceFn,
14923 pub(crate) handle: crate::vk::Device,
14924 }
14925 impl Device {
14926 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
14927 let handle = device.handle();
14928 let fp = DeviceFn::load(|name| unsafe {
14929 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
14930 });
14931 Self { handle, fp }
14932 }
14933 #[inline]
14934 pub fn fp(&self) -> &DeviceFn {
14935 &self.fp
14936 }
14937 #[inline]
14938 pub fn device(&self) -> crate::vk::Device {
14939 self.handle
14940 }
14941 }
14942 #[derive(Clone)]
14943 #[doc = "Raw VK_KHR_dynamic_rendering_local_read device-level function pointers"]
14944 pub struct DeviceFn {
14945 pub cmd_set_rendering_attachment_locations_khr:
14946 PFN_vkCmdSetRenderingAttachmentLocationsKHR,
14947 pub cmd_set_rendering_input_attachment_indices_khr:
14948 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR,
14949 }
14950 unsafe impl Send for DeviceFn {}
14951 unsafe impl Sync for DeviceFn {}
14952 impl DeviceFn {
14953 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
14954 Self::load_erased(&mut f)
14955 }
14956 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
14957 Self {
14958 cmd_set_rendering_attachment_locations_khr: unsafe {
14959 unsafe extern "system" fn cmd_set_rendering_attachment_locations_khr(
14960 _command_buffer: CommandBuffer,
14961 _p_location_info: *const RenderingAttachmentLocationInfoKHR<'_>,
14962 ) {
14963 panic!(concat!(
14964 "Unable to load ",
14965 stringify!(cmd_set_rendering_attachment_locations_khr)
14966 ))
14967 }
14968 let cname = CStr::from_bytes_with_nul_unchecked(
14969 b"vkCmdSetRenderingAttachmentLocationsKHR\0",
14970 );
14971 let val = _f(cname);
14972 if val.is_null() {
14973 cmd_set_rendering_attachment_locations_khr
14974 } else {
14975 ::core::mem::transmute(val)
14976 }
14977 },
14978 cmd_set_rendering_input_attachment_indices_khr: unsafe {
14979 unsafe extern "system" fn cmd_set_rendering_input_attachment_indices_khr(
14980 _command_buffer: CommandBuffer,
14981 _p_location_info: *const RenderingInputAttachmentIndexInfoKHR<'_>,
14982 ) {
14983 panic!(concat!(
14984 "Unable to load ",
14985 stringify!(cmd_set_rendering_input_attachment_indices_khr)
14986 ))
14987 }
14988 let cname = CStr::from_bytes_with_nul_unchecked(
14989 b"vkCmdSetRenderingInputAttachmentIndicesKHR\0",
14990 );
14991 let val = _f(cname);
14992 if val.is_null() {
14993 cmd_set_rendering_input_attachment_indices_khr
14994 } else {
14995 ::core::mem::transmute(val)
14996 }
14997 },
14998 }
14999 }
15000 }
15001 }
15002 #[doc = "VK_KHR_shader_quad_control"]
15003 pub mod shader_quad_control {
15004 use super::super::*;
15005 pub use {
15006 crate::vk::KHR_SHADER_QUAD_CONTROL_NAME as NAME,
15007 crate::vk::KHR_SHADER_QUAD_CONTROL_SPEC_VERSION as SPEC_VERSION,
15008 };
15009 }
15010 #[doc = "VK_KHR_spirv_1_4"]
15011 pub mod spirv_1_4 {
15012 use super::super::*;
15013 pub use {
15014 crate::vk::KHR_SPIRV_1_4_NAME as NAME,
15015 crate::vk::KHR_SPIRV_1_4_SPEC_VERSION as SPEC_VERSION,
15016 };
15017 }
15018 #[doc = "VK_KHR_surface_protected_capabilities"]
15019 pub mod surface_protected_capabilities {
15020 use super::super::*;
15021 pub use {
15022 crate::vk::KHR_SURFACE_PROTECTED_CAPABILITIES_NAME as NAME,
15023 crate::vk::KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION as SPEC_VERSION,
15024 };
15025 }
15026 #[doc = "VK_KHR_separate_depth_stencil_layouts"]
15027 pub mod separate_depth_stencil_layouts {
15028 use super::super::*;
15029 pub use {
15030 crate::vk::KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_NAME as NAME,
15031 crate::vk::KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION as SPEC_VERSION,
15032 };
15033 }
15034 #[doc = "VK_KHR_present_wait"]
15035 pub mod present_wait {
15036 use super::super::*;
15037 pub use {
15038 crate::vk::KHR_PRESENT_WAIT_NAME as NAME,
15039 crate::vk::KHR_PRESENT_WAIT_SPEC_VERSION as SPEC_VERSION,
15040 };
15041 #[doc = "VK_KHR_present_wait device-level functions"]
15042 #[derive(Clone)]
15043 pub struct Device {
15044 pub(crate) fp: DeviceFn,
15045 pub(crate) handle: crate::vk::Device,
15046 }
15047 impl Device {
15048 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15049 let handle = device.handle();
15050 let fp = DeviceFn::load(|name| unsafe {
15051 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15052 });
15053 Self { handle, fp }
15054 }
15055 #[inline]
15056 pub fn fp(&self) -> &DeviceFn {
15057 &self.fp
15058 }
15059 #[inline]
15060 pub fn device(&self) -> crate::vk::Device {
15061 self.handle
15062 }
15063 }
15064 #[derive(Clone)]
15065 #[doc = "Raw VK_KHR_present_wait device-level function pointers"]
15066 pub struct DeviceFn {
15067 pub wait_for_present_khr: PFN_vkWaitForPresentKHR,
15068 }
15069 unsafe impl Send for DeviceFn {}
15070 unsafe impl Sync for DeviceFn {}
15071 impl DeviceFn {
15072 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15073 Self::load_erased(&mut f)
15074 }
15075 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15076 Self {
15077 wait_for_present_khr: unsafe {
15078 unsafe extern "system" fn wait_for_present_khr(
15079 _device: crate::vk::Device,
15080 _swapchain: SwapchainKHR,
15081 _present_id: u64,
15082 _timeout: u64,
15083 ) -> Result {
15084 panic!(concat!("Unable to load ", stringify!(wait_for_present_khr)))
15085 }
15086 let cname = CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0");
15087 let val = _f(cname);
15088 if val.is_null() {
15089 wait_for_present_khr
15090 } else {
15091 ::core::mem::transmute(val)
15092 }
15093 },
15094 }
15095 }
15096 }
15097 }
15098 #[doc = "VK_KHR_uniform_buffer_standard_layout"]
15099 pub mod uniform_buffer_standard_layout {
15100 use super::super::*;
15101 pub use {
15102 crate::vk::KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_NAME as NAME,
15103 crate::vk::KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION as SPEC_VERSION,
15104 };
15105 }
15106 #[doc = "VK_KHR_buffer_device_address"]
15107 pub mod buffer_device_address {
15108 use super::super::*;
15109 pub use {
15110 crate::vk::KHR_BUFFER_DEVICE_ADDRESS_NAME as NAME,
15111 crate::vk::KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION as SPEC_VERSION,
15112 };
15113 #[doc = "VK_KHR_buffer_device_address device-level functions"]
15114 #[derive(Clone)]
15115 pub struct Device {
15116 pub(crate) fp: DeviceFn,
15117 pub(crate) handle: crate::vk::Device,
15118 }
15119 impl Device {
15120 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15121 let handle = device.handle();
15122 let fp = DeviceFn::load(|name| unsafe {
15123 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15124 });
15125 Self { handle, fp }
15126 }
15127 #[inline]
15128 pub fn fp(&self) -> &DeviceFn {
15129 &self.fp
15130 }
15131 #[inline]
15132 pub fn device(&self) -> crate::vk::Device {
15133 self.handle
15134 }
15135 }
15136 #[derive(Clone)]
15137 #[doc = "Raw VK_KHR_buffer_device_address device-level function pointers"]
15138 pub struct DeviceFn {
15139 pub get_buffer_device_address_khr: PFN_vkGetBufferDeviceAddress,
15140 pub get_buffer_opaque_capture_address_khr: PFN_vkGetBufferOpaqueCaptureAddress,
15141 pub get_device_memory_opaque_capture_address_khr:
15142 PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
15143 }
15144 unsafe impl Send for DeviceFn {}
15145 unsafe impl Sync for DeviceFn {}
15146 impl DeviceFn {
15147 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15148 Self::load_erased(&mut f)
15149 }
15150 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15151 Self {
15152 get_buffer_device_address_khr: unsafe {
15153 unsafe extern "system" fn get_buffer_device_address_khr(
15154 _device: crate::vk::Device,
15155 _p_info: *const BufferDeviceAddressInfo<'_>,
15156 ) -> DeviceAddress {
15157 panic!(concat!(
15158 "Unable to load ",
15159 stringify!(get_buffer_device_address_khr)
15160 ))
15161 }
15162 let cname =
15163 CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddressKHR\0");
15164 let val = _f(cname);
15165 if val.is_null() {
15166 get_buffer_device_address_khr
15167 } else {
15168 ::core::mem::transmute(val)
15169 }
15170 },
15171 get_buffer_opaque_capture_address_khr: unsafe {
15172 unsafe extern "system" fn get_buffer_opaque_capture_address_khr(
15173 _device: crate::vk::Device,
15174 _p_info: *const BufferDeviceAddressInfo<'_>,
15175 ) -> u64 {
15176 panic!(concat!(
15177 "Unable to load ",
15178 stringify!(get_buffer_opaque_capture_address_khr)
15179 ))
15180 }
15181 let cname = CStr::from_bytes_with_nul_unchecked(
15182 b"vkGetBufferOpaqueCaptureAddressKHR\0",
15183 );
15184 let val = _f(cname);
15185 if val.is_null() {
15186 get_buffer_opaque_capture_address_khr
15187 } else {
15188 ::core::mem::transmute(val)
15189 }
15190 },
15191 get_device_memory_opaque_capture_address_khr: unsafe {
15192 unsafe extern "system" fn get_device_memory_opaque_capture_address_khr(
15193 _device: crate::vk::Device,
15194 _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo<'_>,
15195 ) -> u64 {
15196 panic!(concat!(
15197 "Unable to load ",
15198 stringify!(get_device_memory_opaque_capture_address_khr)
15199 ))
15200 }
15201 let cname = CStr::from_bytes_with_nul_unchecked(
15202 b"vkGetDeviceMemoryOpaqueCaptureAddressKHR\0",
15203 );
15204 let val = _f(cname);
15205 if val.is_null() {
15206 get_device_memory_opaque_capture_address_khr
15207 } else {
15208 ::core::mem::transmute(val)
15209 }
15210 },
15211 }
15212 }
15213 }
15214 }
15215 #[doc = "VK_KHR_deferred_host_operations"]
15216 pub mod deferred_host_operations {
15217 use super::super::*;
15218 pub use {
15219 crate::vk::KHR_DEFERRED_HOST_OPERATIONS_NAME as NAME,
15220 crate::vk::KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION as SPEC_VERSION,
15221 };
15222 #[doc = "VK_KHR_deferred_host_operations device-level functions"]
15223 #[derive(Clone)]
15224 pub struct Device {
15225 pub(crate) fp: DeviceFn,
15226 pub(crate) handle: crate::vk::Device,
15227 }
15228 impl Device {
15229 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15230 let handle = device.handle();
15231 let fp = DeviceFn::load(|name| unsafe {
15232 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15233 });
15234 Self { handle, fp }
15235 }
15236 #[inline]
15237 pub fn fp(&self) -> &DeviceFn {
15238 &self.fp
15239 }
15240 #[inline]
15241 pub fn device(&self) -> crate::vk::Device {
15242 self.handle
15243 }
15244 }
15245 #[derive(Clone)]
15246 #[doc = "Raw VK_KHR_deferred_host_operations device-level function pointers"]
15247 pub struct DeviceFn {
15248 pub create_deferred_operation_khr: PFN_vkCreateDeferredOperationKHR,
15249 pub destroy_deferred_operation_khr: PFN_vkDestroyDeferredOperationKHR,
15250 pub get_deferred_operation_max_concurrency_khr:
15251 PFN_vkGetDeferredOperationMaxConcurrencyKHR,
15252 pub get_deferred_operation_result_khr: PFN_vkGetDeferredOperationResultKHR,
15253 pub deferred_operation_join_khr: PFN_vkDeferredOperationJoinKHR,
15254 }
15255 unsafe impl Send for DeviceFn {}
15256 unsafe impl Sync for DeviceFn {}
15257 impl DeviceFn {
15258 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15259 Self::load_erased(&mut f)
15260 }
15261 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15262 Self {
15263 create_deferred_operation_khr: unsafe {
15264 unsafe extern "system" fn create_deferred_operation_khr(
15265 _device: crate::vk::Device,
15266 _p_allocator: *const AllocationCallbacks<'_>,
15267 _p_deferred_operation: *mut DeferredOperationKHR,
15268 ) -> Result {
15269 panic!(concat!(
15270 "Unable to load ",
15271 stringify!(create_deferred_operation_khr)
15272 ))
15273 }
15274 let cname =
15275 CStr::from_bytes_with_nul_unchecked(b"vkCreateDeferredOperationKHR\0");
15276 let val = _f(cname);
15277 if val.is_null() {
15278 create_deferred_operation_khr
15279 } else {
15280 ::core::mem::transmute(val)
15281 }
15282 },
15283 destroy_deferred_operation_khr: unsafe {
15284 unsafe extern "system" fn destroy_deferred_operation_khr(
15285 _device: crate::vk::Device,
15286 _operation: DeferredOperationKHR,
15287 _p_allocator: *const AllocationCallbacks<'_>,
15288 ) {
15289 panic!(concat!(
15290 "Unable to load ",
15291 stringify!(destroy_deferred_operation_khr)
15292 ))
15293 }
15294 let cname =
15295 CStr::from_bytes_with_nul_unchecked(b"vkDestroyDeferredOperationKHR\0");
15296 let val = _f(cname);
15297 if val.is_null() {
15298 destroy_deferred_operation_khr
15299 } else {
15300 ::core::mem::transmute(val)
15301 }
15302 },
15303 get_deferred_operation_max_concurrency_khr: unsafe {
15304 unsafe extern "system" fn get_deferred_operation_max_concurrency_khr(
15305 _device: crate::vk::Device,
15306 _operation: DeferredOperationKHR,
15307 ) -> u32 {
15308 panic!(concat!(
15309 "Unable to load ",
15310 stringify!(get_deferred_operation_max_concurrency_khr)
15311 ))
15312 }
15313 let cname = CStr::from_bytes_with_nul_unchecked(
15314 b"vkGetDeferredOperationMaxConcurrencyKHR\0",
15315 );
15316 let val = _f(cname);
15317 if val.is_null() {
15318 get_deferred_operation_max_concurrency_khr
15319 } else {
15320 ::core::mem::transmute(val)
15321 }
15322 },
15323 get_deferred_operation_result_khr: unsafe {
15324 unsafe extern "system" fn get_deferred_operation_result_khr(
15325 _device: crate::vk::Device,
15326 _operation: DeferredOperationKHR,
15327 ) -> Result {
15328 panic!(concat!(
15329 "Unable to load ",
15330 stringify!(get_deferred_operation_result_khr)
15331 ))
15332 }
15333 let cname = CStr::from_bytes_with_nul_unchecked(
15334 b"vkGetDeferredOperationResultKHR\0",
15335 );
15336 let val = _f(cname);
15337 if val.is_null() {
15338 get_deferred_operation_result_khr
15339 } else {
15340 ::core::mem::transmute(val)
15341 }
15342 },
15343 deferred_operation_join_khr: unsafe {
15344 unsafe extern "system" fn deferred_operation_join_khr(
15345 _device: crate::vk::Device,
15346 _operation: DeferredOperationKHR,
15347 ) -> Result {
15348 panic!(concat!(
15349 "Unable to load ",
15350 stringify!(deferred_operation_join_khr)
15351 ))
15352 }
15353 let cname =
15354 CStr::from_bytes_with_nul_unchecked(b"vkDeferredOperationJoinKHR\0");
15355 let val = _f(cname);
15356 if val.is_null() {
15357 deferred_operation_join_khr
15358 } else {
15359 ::core::mem::transmute(val)
15360 }
15361 },
15362 }
15363 }
15364 }
15365 }
15366 #[doc = "VK_KHR_pipeline_executable_properties"]
15367 pub mod pipeline_executable_properties {
15368 use super::super::*;
15369 pub use {
15370 crate::vk::KHR_PIPELINE_EXECUTABLE_PROPERTIES_NAME as NAME,
15371 crate::vk::KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
15372 };
15373 #[doc = "VK_KHR_pipeline_executable_properties device-level functions"]
15374 #[derive(Clone)]
15375 pub struct Device {
15376 pub(crate) fp: DeviceFn,
15377 pub(crate) handle: crate::vk::Device,
15378 }
15379 impl Device {
15380 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15381 let handle = device.handle();
15382 let fp = DeviceFn::load(|name| unsafe {
15383 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15384 });
15385 Self { handle, fp }
15386 }
15387 #[inline]
15388 pub fn fp(&self) -> &DeviceFn {
15389 &self.fp
15390 }
15391 #[inline]
15392 pub fn device(&self) -> crate::vk::Device {
15393 self.handle
15394 }
15395 }
15396 #[derive(Clone)]
15397 #[doc = "Raw VK_KHR_pipeline_executable_properties device-level function pointers"]
15398 pub struct DeviceFn {
15399 pub get_pipeline_executable_properties_khr: PFN_vkGetPipelineExecutablePropertiesKHR,
15400 pub get_pipeline_executable_statistics_khr: PFN_vkGetPipelineExecutableStatisticsKHR,
15401 pub get_pipeline_executable_internal_representations_khr:
15402 PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
15403 }
15404 unsafe impl Send for DeviceFn {}
15405 unsafe impl Sync for DeviceFn {}
15406 impl DeviceFn {
15407 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15408 Self::load_erased(&mut f)
15409 }
15410 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15411 Self {
15412 get_pipeline_executable_properties_khr: unsafe {
15413 unsafe extern "system" fn get_pipeline_executable_properties_khr(
15414 _device: crate::vk::Device,
15415 _p_pipeline_info: *const PipelineInfoKHR<'_>,
15416 _p_executable_count: *mut u32,
15417 _p_properties: *mut PipelineExecutablePropertiesKHR<'_>,
15418 ) -> Result {
15419 panic!(concat!(
15420 "Unable to load ",
15421 stringify!(get_pipeline_executable_properties_khr)
15422 ))
15423 }
15424 let cname = CStr::from_bytes_with_nul_unchecked(
15425 b"vkGetPipelineExecutablePropertiesKHR\0",
15426 );
15427 let val = _f(cname);
15428 if val.is_null() {
15429 get_pipeline_executable_properties_khr
15430 } else {
15431 ::core::mem::transmute(val)
15432 }
15433 },
15434 get_pipeline_executable_statistics_khr: unsafe {
15435 unsafe extern "system" fn get_pipeline_executable_statistics_khr(
15436 _device: crate::vk::Device,
15437 _p_executable_info: *const PipelineExecutableInfoKHR<'_>,
15438 _p_statistic_count: *mut u32,
15439 _p_statistics: *mut PipelineExecutableStatisticKHR<'_>,
15440 ) -> Result {
15441 panic!(concat!(
15442 "Unable to load ",
15443 stringify!(get_pipeline_executable_statistics_khr)
15444 ))
15445 }
15446 let cname = CStr::from_bytes_with_nul_unchecked(
15447 b"vkGetPipelineExecutableStatisticsKHR\0",
15448 );
15449 let val = _f(cname);
15450 if val.is_null() {
15451 get_pipeline_executable_statistics_khr
15452 } else {
15453 ::core::mem::transmute(val)
15454 }
15455 },
15456 get_pipeline_executable_internal_representations_khr: unsafe {
15457 unsafe extern "system" fn get_pipeline_executable_internal_representations_khr(
15458 _device: crate::vk::Device,
15459 _p_executable_info: *const PipelineExecutableInfoKHR<'_>,
15460 _p_internal_representation_count: *mut u32,
15461 _p_internal_representations : * mut PipelineExecutableInternalRepresentationKHR < '_ >,
15462 ) -> Result {
15463 panic!(concat!(
15464 "Unable to load ",
15465 stringify!(get_pipeline_executable_internal_representations_khr)
15466 ))
15467 }
15468 let cname = CStr::from_bytes_with_nul_unchecked(
15469 b"vkGetPipelineExecutableInternalRepresentationsKHR\0",
15470 );
15471 let val = _f(cname);
15472 if val.is_null() {
15473 get_pipeline_executable_internal_representations_khr
15474 } else {
15475 ::core::mem::transmute(val)
15476 }
15477 },
15478 }
15479 }
15480 }
15481 }
15482 #[doc = "VK_KHR_map_memory2"]
15483 pub mod map_memory2 {
15484 use super::super::*;
15485 pub use {
15486 crate::vk::KHR_MAP_MEMORY2_NAME as NAME,
15487 crate::vk::KHR_MAP_MEMORY2_SPEC_VERSION as SPEC_VERSION,
15488 };
15489 #[doc = "VK_KHR_map_memory2 device-level functions"]
15490 #[derive(Clone)]
15491 pub struct Device {
15492 pub(crate) fp: DeviceFn,
15493 pub(crate) handle: crate::vk::Device,
15494 }
15495 impl Device {
15496 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15497 let handle = device.handle();
15498 let fp = DeviceFn::load(|name| unsafe {
15499 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15500 });
15501 Self { handle, fp }
15502 }
15503 #[inline]
15504 pub fn fp(&self) -> &DeviceFn {
15505 &self.fp
15506 }
15507 #[inline]
15508 pub fn device(&self) -> crate::vk::Device {
15509 self.handle
15510 }
15511 }
15512 #[derive(Clone)]
15513 #[doc = "Raw VK_KHR_map_memory2 device-level function pointers"]
15514 pub struct DeviceFn {
15515 pub map_memory2_khr: PFN_vkMapMemory2KHR,
15516 pub unmap_memory2_khr: PFN_vkUnmapMemory2KHR,
15517 }
15518 unsafe impl Send for DeviceFn {}
15519 unsafe impl Sync for DeviceFn {}
15520 impl DeviceFn {
15521 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15522 Self::load_erased(&mut f)
15523 }
15524 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15525 Self {
15526 map_memory2_khr: unsafe {
15527 unsafe extern "system" fn map_memory2_khr(
15528 _device: crate::vk::Device,
15529 _p_memory_map_info: *const MemoryMapInfoKHR<'_>,
15530 _pp_data: *mut *mut c_void,
15531 ) -> Result {
15532 panic!(concat!("Unable to load ", stringify!(map_memory2_khr)))
15533 }
15534 let cname = CStr::from_bytes_with_nul_unchecked(b"vkMapMemory2KHR\0");
15535 let val = _f(cname);
15536 if val.is_null() {
15537 map_memory2_khr
15538 } else {
15539 ::core::mem::transmute(val)
15540 }
15541 },
15542 unmap_memory2_khr: unsafe {
15543 unsafe extern "system" fn unmap_memory2_khr(
15544 _device: crate::vk::Device,
15545 _p_memory_unmap_info: *const MemoryUnmapInfoKHR<'_>,
15546 ) -> Result {
15547 panic!(concat!("Unable to load ", stringify!(unmap_memory2_khr)))
15548 }
15549 let cname = CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory2KHR\0");
15550 let val = _f(cname);
15551 if val.is_null() {
15552 unmap_memory2_khr
15553 } else {
15554 ::core::mem::transmute(val)
15555 }
15556 },
15557 }
15558 }
15559 }
15560 }
15561 #[doc = "VK_KHR_shader_integer_dot_product"]
15562 pub mod shader_integer_dot_product {
15563 use super::super::*;
15564 pub use {
15565 crate::vk::KHR_SHADER_INTEGER_DOT_PRODUCT_NAME as NAME,
15566 crate::vk::KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION as SPEC_VERSION,
15567 };
15568 }
15569 #[doc = "VK_KHR_pipeline_library"]
15570 pub mod pipeline_library {
15571 use super::super::*;
15572 pub use {
15573 crate::vk::KHR_PIPELINE_LIBRARY_NAME as NAME,
15574 crate::vk::KHR_PIPELINE_LIBRARY_SPEC_VERSION as SPEC_VERSION,
15575 };
15576 }
15577 #[doc = "VK_KHR_shader_non_semantic_info"]
15578 pub mod shader_non_semantic_info {
15579 use super::super::*;
15580 pub use {
15581 crate::vk::KHR_SHADER_NON_SEMANTIC_INFO_NAME as NAME,
15582 crate::vk::KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION as SPEC_VERSION,
15583 };
15584 }
15585 #[doc = "VK_KHR_present_id"]
15586 pub mod present_id {
15587 use super::super::*;
15588 pub use {
15589 crate::vk::KHR_PRESENT_ID_NAME as NAME,
15590 crate::vk::KHR_PRESENT_ID_SPEC_VERSION as SPEC_VERSION,
15591 };
15592 }
15593 #[doc = "VK_KHR_video_encode_queue"]
15594 pub mod video_encode_queue {
15595 use super::super::*;
15596 pub use {
15597 crate::vk::KHR_VIDEO_ENCODE_QUEUE_NAME as NAME,
15598 crate::vk::KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION as SPEC_VERSION,
15599 };
15600 #[doc = "VK_KHR_video_encode_queue instance-level functions"]
15601 #[derive(Clone)]
15602 pub struct Instance {
15603 pub(crate) fp: InstanceFn,
15604 pub(crate) handle: crate::vk::Instance,
15605 }
15606 impl Instance {
15607 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
15608 let handle = instance.handle();
15609 let fp = InstanceFn::load(|name| unsafe {
15610 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
15611 });
15612 Self { handle, fp }
15613 }
15614 #[inline]
15615 pub fn fp(&self) -> &InstanceFn {
15616 &self.fp
15617 }
15618 #[inline]
15619 pub fn instance(&self) -> crate::vk::Instance {
15620 self.handle
15621 }
15622 }
15623 #[derive(Clone)]
15624 #[doc = "Raw VK_KHR_video_encode_queue instance-level function pointers"]
15625 pub struct InstanceFn {
15626 pub get_physical_device_video_encode_quality_level_properties_khr:
15627 PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR,
15628 }
15629 unsafe impl Send for InstanceFn {}
15630 unsafe impl Sync for InstanceFn {}
15631 impl InstanceFn {
15632 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15633 Self::load_erased(&mut f)
15634 }
15635 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15636 Self {
15637 get_physical_device_video_encode_quality_level_properties_khr: unsafe {
15638 unsafe extern "system" fn get_physical_device_video_encode_quality_level_properties_khr(
15639 _physical_device: PhysicalDevice,
15640 _p_quality_level_info : * const PhysicalDeviceVideoEncodeQualityLevelInfoKHR < '_ >,
15641 _p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR<
15642 '_,
15643 >,
15644 ) -> Result {
15645 panic!(concat!(
15646 "Unable to load ",
15647 stringify!(
15648 get_physical_device_video_encode_quality_level_properties_khr
15649 )
15650 ))
15651 }
15652 let cname = CStr::from_bytes_with_nul_unchecked(
15653 b"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\0",
15654 );
15655 let val = _f(cname);
15656 if val.is_null() {
15657 get_physical_device_video_encode_quality_level_properties_khr
15658 } else {
15659 ::core::mem::transmute(val)
15660 }
15661 },
15662 }
15663 }
15664 }
15665 #[doc = "VK_KHR_video_encode_queue device-level functions"]
15666 #[derive(Clone)]
15667 pub struct Device {
15668 pub(crate) fp: DeviceFn,
15669 pub(crate) handle: crate::vk::Device,
15670 }
15671 impl Device {
15672 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15673 let handle = device.handle();
15674 let fp = DeviceFn::load(|name| unsafe {
15675 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15676 });
15677 Self { handle, fp }
15678 }
15679 #[inline]
15680 pub fn fp(&self) -> &DeviceFn {
15681 &self.fp
15682 }
15683 #[inline]
15684 pub fn device(&self) -> crate::vk::Device {
15685 self.handle
15686 }
15687 }
15688 #[derive(Clone)]
15689 #[doc = "Raw VK_KHR_video_encode_queue device-level function pointers"]
15690 pub struct DeviceFn {
15691 pub get_encoded_video_session_parameters_khr: PFN_vkGetEncodedVideoSessionParametersKHR,
15692 pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR,
15693 }
15694 unsafe impl Send for DeviceFn {}
15695 unsafe impl Sync for DeviceFn {}
15696 impl DeviceFn {
15697 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15698 Self::load_erased(&mut f)
15699 }
15700 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15701 Self {
15702 get_encoded_video_session_parameters_khr: unsafe {
15703 unsafe extern "system" fn get_encoded_video_session_parameters_khr(
15704 _device: crate::vk::Device,
15705 _p_video_session_parameters_info : * const VideoEncodeSessionParametersGetInfoKHR < '_ >,
15706 _p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
15707 _p_data_size: *mut usize,
15708 _p_data: *mut c_void,
15709 ) -> Result {
15710 panic!(concat!(
15711 "Unable to load ",
15712 stringify!(get_encoded_video_session_parameters_khr)
15713 ))
15714 }
15715 let cname = CStr::from_bytes_with_nul_unchecked(
15716 b"vkGetEncodedVideoSessionParametersKHR\0",
15717 );
15718 let val = _f(cname);
15719 if val.is_null() {
15720 get_encoded_video_session_parameters_khr
15721 } else {
15722 ::core::mem::transmute(val)
15723 }
15724 },
15725 cmd_encode_video_khr: unsafe {
15726 unsafe extern "system" fn cmd_encode_video_khr(
15727 _command_buffer: CommandBuffer,
15728 _p_encode_info: *const VideoEncodeInfoKHR<'_>,
15729 ) {
15730 panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr)))
15731 }
15732 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0");
15733 let val = _f(cname);
15734 if val.is_null() {
15735 cmd_encode_video_khr
15736 } else {
15737 ::core::mem::transmute(val)
15738 }
15739 },
15740 }
15741 }
15742 }
15743 }
15744 #[doc = "VK_KHR_synchronization2"]
15745 pub mod synchronization2 {
15746 use super::super::*;
15747 pub use {
15748 crate::vk::KHR_SYNCHRONIZATION2_NAME as NAME,
15749 crate::vk::KHR_SYNCHRONIZATION2_SPEC_VERSION as SPEC_VERSION,
15750 };
15751 #[doc = "VK_KHR_synchronization2 device-level functions"]
15752 #[derive(Clone)]
15753 pub struct Device {
15754 pub(crate) fp: DeviceFn,
15755 pub(crate) handle: crate::vk::Device,
15756 }
15757 impl Device {
15758 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15759 let handle = device.handle();
15760 let fp = DeviceFn::load(|name| unsafe {
15761 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15762 });
15763 Self { handle, fp }
15764 }
15765 #[inline]
15766 pub fn fp(&self) -> &DeviceFn {
15767 &self.fp
15768 }
15769 #[inline]
15770 pub fn device(&self) -> crate::vk::Device {
15771 self.handle
15772 }
15773 }
15774 #[derive(Clone)]
15775 #[doc = "Raw VK_KHR_synchronization2 device-level function pointers"]
15776 pub struct DeviceFn {
15777 pub cmd_set_event2_khr: PFN_vkCmdSetEvent2,
15778 pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2,
15779 pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2,
15780 pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2,
15781 pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2,
15782 pub queue_submit2_khr: PFN_vkQueueSubmit2,
15783 pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD,
15784 pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV,
15785 }
15786 unsafe impl Send for DeviceFn {}
15787 unsafe impl Sync for DeviceFn {}
15788 impl DeviceFn {
15789 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
15790 Self::load_erased(&mut f)
15791 }
15792 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
15793 Self {
15794 cmd_set_event2_khr: unsafe {
15795 unsafe extern "system" fn cmd_set_event2_khr(
15796 _command_buffer: CommandBuffer,
15797 _event: Event,
15798 _p_dependency_info: *const DependencyInfo<'_>,
15799 ) {
15800 panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr)))
15801 }
15802 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2KHR\0");
15803 let val = _f(cname);
15804 if val.is_null() {
15805 cmd_set_event2_khr
15806 } else {
15807 ::core::mem::transmute(val)
15808 }
15809 },
15810 cmd_reset_event2_khr: unsafe {
15811 unsafe extern "system" fn cmd_reset_event2_khr(
15812 _command_buffer: CommandBuffer,
15813 _event: Event,
15814 _stage_mask: PipelineStageFlags2,
15815 ) {
15816 panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr)))
15817 }
15818 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2KHR\0");
15819 let val = _f(cname);
15820 if val.is_null() {
15821 cmd_reset_event2_khr
15822 } else {
15823 ::core::mem::transmute(val)
15824 }
15825 },
15826 cmd_wait_events2_khr: unsafe {
15827 unsafe extern "system" fn cmd_wait_events2_khr(
15828 _command_buffer: CommandBuffer,
15829 _event_count: u32,
15830 _p_events: *const Event,
15831 _p_dependency_infos: *const DependencyInfo<'_>,
15832 ) {
15833 panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr)))
15834 }
15835 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2KHR\0");
15836 let val = _f(cname);
15837 if val.is_null() {
15838 cmd_wait_events2_khr
15839 } else {
15840 ::core::mem::transmute(val)
15841 }
15842 },
15843 cmd_pipeline_barrier2_khr: unsafe {
15844 unsafe extern "system" fn cmd_pipeline_barrier2_khr(
15845 _command_buffer: CommandBuffer,
15846 _p_dependency_info: *const DependencyInfo<'_>,
15847 ) {
15848 panic!(concat!(
15849 "Unable to load ",
15850 stringify!(cmd_pipeline_barrier2_khr)
15851 ))
15852 }
15853 let cname =
15854 CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2KHR\0");
15855 let val = _f(cname);
15856 if val.is_null() {
15857 cmd_pipeline_barrier2_khr
15858 } else {
15859 ::core::mem::transmute(val)
15860 }
15861 },
15862 cmd_write_timestamp2_khr: unsafe {
15863 unsafe extern "system" fn cmd_write_timestamp2_khr(
15864 _command_buffer: CommandBuffer,
15865 _stage: PipelineStageFlags2,
15866 _query_pool: QueryPool,
15867 _query: u32,
15868 ) {
15869 panic!(concat!(
15870 "Unable to load ",
15871 stringify!(cmd_write_timestamp2_khr)
15872 ))
15873 }
15874 let cname =
15875 CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2KHR\0");
15876 let val = _f(cname);
15877 if val.is_null() {
15878 cmd_write_timestamp2_khr
15879 } else {
15880 ::core::mem::transmute(val)
15881 }
15882 },
15883 queue_submit2_khr: unsafe {
15884 unsafe extern "system" fn queue_submit2_khr(
15885 _queue: Queue,
15886 _submit_count: u32,
15887 _p_submits: *const SubmitInfo2<'_>,
15888 _fence: Fence,
15889 ) -> Result {
15890 panic!(concat!("Unable to load ", stringify!(queue_submit2_khr)))
15891 }
15892 let cname = CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2KHR\0");
15893 let val = _f(cname);
15894 if val.is_null() {
15895 queue_submit2_khr
15896 } else {
15897 ::core::mem::transmute(val)
15898 }
15899 },
15900 cmd_write_buffer_marker2_amd: unsafe {
15901 unsafe extern "system" fn cmd_write_buffer_marker2_amd(
15902 _command_buffer: CommandBuffer,
15903 _stage: PipelineStageFlags2,
15904 _dst_buffer: Buffer,
15905 _dst_offset: DeviceSize,
15906 _marker: u32,
15907 ) {
15908 panic!(concat!(
15909 "Unable to load ",
15910 stringify!(cmd_write_buffer_marker2_amd)
15911 ))
15912 }
15913 let cname =
15914 CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarker2AMD\0");
15915 let val = _f(cname);
15916 if val.is_null() {
15917 cmd_write_buffer_marker2_amd
15918 } else {
15919 ::core::mem::transmute(val)
15920 }
15921 },
15922 get_queue_checkpoint_data2_nv: unsafe {
15923 unsafe extern "system" fn get_queue_checkpoint_data2_nv(
15924 _queue: Queue,
15925 _p_checkpoint_data_count: *mut u32,
15926 _p_checkpoint_data: *mut CheckpointData2NV<'_>,
15927 ) {
15928 panic!(concat!(
15929 "Unable to load ",
15930 stringify!(get_queue_checkpoint_data2_nv)
15931 ))
15932 }
15933 let cname =
15934 CStr::from_bytes_with_nul_unchecked(b"vkGetQueueCheckpointData2NV\0");
15935 let val = _f(cname);
15936 if val.is_null() {
15937 get_queue_checkpoint_data2_nv
15938 } else {
15939 ::core::mem::transmute(val)
15940 }
15941 },
15942 }
15943 }
15944 }
15945 }
15946 #[doc = "VK_KHR_fragment_shader_barycentric"]
15947 pub mod fragment_shader_barycentric {
15948 use super::super::*;
15949 pub use {
15950 crate::vk::KHR_FRAGMENT_SHADER_BARYCENTRIC_NAME as NAME,
15951 crate::vk::KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION as SPEC_VERSION,
15952 };
15953 }
15954 #[doc = "VK_KHR_shader_subgroup_uniform_control_flow"]
15955 pub mod shader_subgroup_uniform_control_flow {
15956 use super::super::*;
15957 pub use {
15958 crate::vk::KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_NAME as NAME,
15959 crate::vk::KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION as SPEC_VERSION,
15960 };
15961 }
15962 #[doc = "VK_KHR_zero_initialize_workgroup_memory"]
15963 pub mod zero_initialize_workgroup_memory {
15964 use super::super::*;
15965 pub use {
15966 crate::vk::KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_NAME as NAME,
15967 crate::vk::KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION as SPEC_VERSION,
15968 };
15969 }
15970 #[doc = "VK_KHR_workgroup_memory_explicit_layout"]
15971 pub mod workgroup_memory_explicit_layout {
15972 use super::super::*;
15973 pub use {
15974 crate::vk::KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_NAME as NAME,
15975 crate::vk::KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION as SPEC_VERSION,
15976 };
15977 }
15978 #[doc = "VK_KHR_copy_commands2"]
15979 pub mod copy_commands2 {
15980 use super::super::*;
15981 pub use {
15982 crate::vk::KHR_COPY_COMMANDS2_NAME as NAME,
15983 crate::vk::KHR_COPY_COMMANDS2_SPEC_VERSION as SPEC_VERSION,
15984 };
15985 #[doc = "VK_KHR_copy_commands2 device-level functions"]
15986 #[derive(Clone)]
15987 pub struct Device {
15988 pub(crate) fp: DeviceFn,
15989 pub(crate) handle: crate::vk::Device,
15990 }
15991 impl Device {
15992 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
15993 let handle = device.handle();
15994 let fp = DeviceFn::load(|name| unsafe {
15995 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
15996 });
15997 Self { handle, fp }
15998 }
15999 #[inline]
16000 pub fn fp(&self) -> &DeviceFn {
16001 &self.fp
16002 }
16003 #[inline]
16004 pub fn device(&self) -> crate::vk::Device {
16005 self.handle
16006 }
16007 }
16008 #[derive(Clone)]
16009 #[doc = "Raw VK_KHR_copy_commands2 device-level function pointers"]
16010 pub struct DeviceFn {
16011 pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2,
16012 pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2,
16013 pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2,
16014 pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2,
16015 pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2,
16016 pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2,
16017 }
16018 unsafe impl Send for DeviceFn {}
16019 unsafe impl Sync for DeviceFn {}
16020 impl DeviceFn {
16021 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16022 Self::load_erased(&mut f)
16023 }
16024 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16025 Self {
16026 cmd_copy_buffer2_khr: unsafe {
16027 unsafe extern "system" fn cmd_copy_buffer2_khr(
16028 _command_buffer: CommandBuffer,
16029 _p_copy_buffer_info: *const CopyBufferInfo2<'_>,
16030 ) {
16031 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr)))
16032 }
16033 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2KHR\0");
16034 let val = _f(cname);
16035 if val.is_null() {
16036 cmd_copy_buffer2_khr
16037 } else {
16038 ::core::mem::transmute(val)
16039 }
16040 },
16041 cmd_copy_image2_khr: unsafe {
16042 unsafe extern "system" fn cmd_copy_image2_khr(
16043 _command_buffer: CommandBuffer,
16044 _p_copy_image_info: *const CopyImageInfo2<'_>,
16045 ) {
16046 panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr)))
16047 }
16048 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2KHR\0");
16049 let val = _f(cname);
16050 if val.is_null() {
16051 cmd_copy_image2_khr
16052 } else {
16053 ::core::mem::transmute(val)
16054 }
16055 },
16056 cmd_copy_buffer_to_image2_khr: unsafe {
16057 unsafe extern "system" fn cmd_copy_buffer_to_image2_khr(
16058 _command_buffer: CommandBuffer,
16059 _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2<'_>,
16060 ) {
16061 panic!(concat!(
16062 "Unable to load ",
16063 stringify!(cmd_copy_buffer_to_image2_khr)
16064 ))
16065 }
16066 let cname =
16067 CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2KHR\0");
16068 let val = _f(cname);
16069 if val.is_null() {
16070 cmd_copy_buffer_to_image2_khr
16071 } else {
16072 ::core::mem::transmute(val)
16073 }
16074 },
16075 cmd_copy_image_to_buffer2_khr: unsafe {
16076 unsafe extern "system" fn cmd_copy_image_to_buffer2_khr(
16077 _command_buffer: CommandBuffer,
16078 _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2<'_>,
16079 ) {
16080 panic!(concat!(
16081 "Unable to load ",
16082 stringify!(cmd_copy_image_to_buffer2_khr)
16083 ))
16084 }
16085 let cname =
16086 CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2KHR\0");
16087 let val = _f(cname);
16088 if val.is_null() {
16089 cmd_copy_image_to_buffer2_khr
16090 } else {
16091 ::core::mem::transmute(val)
16092 }
16093 },
16094 cmd_blit_image2_khr: unsafe {
16095 unsafe extern "system" fn cmd_blit_image2_khr(
16096 _command_buffer: CommandBuffer,
16097 _p_blit_image_info: *const BlitImageInfo2<'_>,
16098 ) {
16099 panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr)))
16100 }
16101 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2KHR\0");
16102 let val = _f(cname);
16103 if val.is_null() {
16104 cmd_blit_image2_khr
16105 } else {
16106 ::core::mem::transmute(val)
16107 }
16108 },
16109 cmd_resolve_image2_khr: unsafe {
16110 unsafe extern "system" fn cmd_resolve_image2_khr(
16111 _command_buffer: CommandBuffer,
16112 _p_resolve_image_info: *const ResolveImageInfo2<'_>,
16113 ) {
16114 panic!(concat!(
16115 "Unable to load ",
16116 stringify!(cmd_resolve_image2_khr)
16117 ))
16118 }
16119 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2KHR\0");
16120 let val = _f(cname);
16121 if val.is_null() {
16122 cmd_resolve_image2_khr
16123 } else {
16124 ::core::mem::transmute(val)
16125 }
16126 },
16127 }
16128 }
16129 }
16130 }
16131 #[doc = "VK_KHR_format_feature_flags2"]
16132 pub mod format_feature_flags2 {
16133 use super::super::*;
16134 pub use {
16135 crate::vk::KHR_FORMAT_FEATURE_FLAGS2_NAME as NAME,
16136 crate::vk::KHR_FORMAT_FEATURE_FLAGS2_SPEC_VERSION as SPEC_VERSION,
16137 };
16138 }
16139 #[doc = "VK_KHR_ray_tracing_maintenance1"]
16140 pub mod ray_tracing_maintenance1 {
16141 use super::super::*;
16142 pub use {
16143 crate::vk::KHR_RAY_TRACING_MAINTENANCE1_NAME as NAME,
16144 crate::vk::KHR_RAY_TRACING_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
16145 };
16146 #[doc = "VK_KHR_ray_tracing_maintenance1 device-level functions"]
16147 #[derive(Clone)]
16148 pub struct Device {
16149 pub(crate) fp: DeviceFn,
16150 pub(crate) handle: crate::vk::Device,
16151 }
16152 impl Device {
16153 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16154 let handle = device.handle();
16155 let fp = DeviceFn::load(|name| unsafe {
16156 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16157 });
16158 Self { handle, fp }
16159 }
16160 #[inline]
16161 pub fn fp(&self) -> &DeviceFn {
16162 &self.fp
16163 }
16164 #[inline]
16165 pub fn device(&self) -> crate::vk::Device {
16166 self.handle
16167 }
16168 }
16169 #[derive(Clone)]
16170 #[doc = "Raw VK_KHR_ray_tracing_maintenance1 device-level function pointers"]
16171 pub struct DeviceFn {
16172 pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR,
16173 }
16174 unsafe impl Send for DeviceFn {}
16175 unsafe impl Sync for DeviceFn {}
16176 impl DeviceFn {
16177 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16178 Self::load_erased(&mut f)
16179 }
16180 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16181 Self {
16182 cmd_trace_rays_indirect2_khr: unsafe {
16183 unsafe extern "system" fn cmd_trace_rays_indirect2_khr(
16184 _command_buffer: CommandBuffer,
16185 _indirect_device_address: DeviceAddress,
16186 ) {
16187 panic!(concat!(
16188 "Unable to load ",
16189 stringify!(cmd_trace_rays_indirect2_khr)
16190 ))
16191 }
16192 let cname =
16193 CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirect2KHR\0");
16194 let val = _f(cname);
16195 if val.is_null() {
16196 cmd_trace_rays_indirect2_khr
16197 } else {
16198 ::core::mem::transmute(val)
16199 }
16200 },
16201 }
16202 }
16203 }
16204 }
16205 #[doc = "VK_KHR_portability_enumeration"]
16206 pub mod portability_enumeration {
16207 use super::super::*;
16208 pub use {
16209 crate::vk::KHR_PORTABILITY_ENUMERATION_NAME as NAME,
16210 crate::vk::KHR_PORTABILITY_ENUMERATION_SPEC_VERSION as SPEC_VERSION,
16211 };
16212 }
16213 #[doc = "VK_KHR_maintenance4"]
16214 pub mod maintenance4 {
16215 use super::super::*;
16216 pub use {
16217 crate::vk::KHR_MAINTENANCE4_NAME as NAME,
16218 crate::vk::KHR_MAINTENANCE4_SPEC_VERSION as SPEC_VERSION,
16219 };
16220 #[doc = "VK_KHR_maintenance4 device-level functions"]
16221 #[derive(Clone)]
16222 pub struct Device {
16223 pub(crate) fp: DeviceFn,
16224 pub(crate) handle: crate::vk::Device,
16225 }
16226 impl Device {
16227 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16228 let handle = device.handle();
16229 let fp = DeviceFn::load(|name| unsafe {
16230 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16231 });
16232 Self { handle, fp }
16233 }
16234 #[inline]
16235 pub fn fp(&self) -> &DeviceFn {
16236 &self.fp
16237 }
16238 #[inline]
16239 pub fn device(&self) -> crate::vk::Device {
16240 self.handle
16241 }
16242 }
16243 #[derive(Clone)]
16244 #[doc = "Raw VK_KHR_maintenance4 device-level function pointers"]
16245 pub struct DeviceFn {
16246 pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements,
16247 pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements,
16248 pub get_device_image_sparse_memory_requirements_khr:
16249 PFN_vkGetDeviceImageSparseMemoryRequirements,
16250 }
16251 unsafe impl Send for DeviceFn {}
16252 unsafe impl Sync for DeviceFn {}
16253 impl DeviceFn {
16254 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16255 Self::load_erased(&mut f)
16256 }
16257 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16258 Self {
16259 get_device_buffer_memory_requirements_khr: unsafe {
16260 unsafe extern "system" fn get_device_buffer_memory_requirements_khr(
16261 _device: crate::vk::Device,
16262 _p_info: *const DeviceBufferMemoryRequirements<'_>,
16263 _p_memory_requirements: *mut MemoryRequirements2<'_>,
16264 ) {
16265 panic!(concat!(
16266 "Unable to load ",
16267 stringify!(get_device_buffer_memory_requirements_khr)
16268 ))
16269 }
16270 let cname = CStr::from_bytes_with_nul_unchecked(
16271 b"vkGetDeviceBufferMemoryRequirementsKHR\0",
16272 );
16273 let val = _f(cname);
16274 if val.is_null() {
16275 get_device_buffer_memory_requirements_khr
16276 } else {
16277 ::core::mem::transmute(val)
16278 }
16279 },
16280 get_device_image_memory_requirements_khr: unsafe {
16281 unsafe extern "system" fn get_device_image_memory_requirements_khr(
16282 _device: crate::vk::Device,
16283 _p_info: *const DeviceImageMemoryRequirements<'_>,
16284 _p_memory_requirements: *mut MemoryRequirements2<'_>,
16285 ) {
16286 panic!(concat!(
16287 "Unable to load ",
16288 stringify!(get_device_image_memory_requirements_khr)
16289 ))
16290 }
16291 let cname = CStr::from_bytes_with_nul_unchecked(
16292 b"vkGetDeviceImageMemoryRequirementsKHR\0",
16293 );
16294 let val = _f(cname);
16295 if val.is_null() {
16296 get_device_image_memory_requirements_khr
16297 } else {
16298 ::core::mem::transmute(val)
16299 }
16300 },
16301 get_device_image_sparse_memory_requirements_khr: unsafe {
16302 unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr(
16303 _device: crate::vk::Device,
16304 _p_info: *const DeviceImageMemoryRequirements<'_>,
16305 _p_sparse_memory_requirement_count: *mut u32,
16306 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2<'_>,
16307 ) {
16308 panic!(concat!(
16309 "Unable to load ",
16310 stringify!(get_device_image_sparse_memory_requirements_khr)
16311 ))
16312 }
16313 let cname = CStr::from_bytes_with_nul_unchecked(
16314 b"vkGetDeviceImageSparseMemoryRequirementsKHR\0",
16315 );
16316 let val = _f(cname);
16317 if val.is_null() {
16318 get_device_image_sparse_memory_requirements_khr
16319 } else {
16320 ::core::mem::transmute(val)
16321 }
16322 },
16323 }
16324 }
16325 }
16326 }
16327 #[doc = "VK_KHR_shader_subgroup_rotate"]
16328 pub mod shader_subgroup_rotate {
16329 use super::super::*;
16330 pub use {
16331 crate::vk::KHR_SHADER_SUBGROUP_ROTATE_NAME as NAME,
16332 crate::vk::KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION as SPEC_VERSION,
16333 };
16334 }
16335 #[doc = "VK_KHR_shader_maximal_reconvergence"]
16336 pub mod shader_maximal_reconvergence {
16337 use super::super::*;
16338 pub use {
16339 crate::vk::KHR_SHADER_MAXIMAL_RECONVERGENCE_NAME as NAME,
16340 crate::vk::KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION as SPEC_VERSION,
16341 };
16342 }
16343 #[doc = "VK_KHR_maintenance5"]
16344 pub mod maintenance5 {
16345 use super::super::*;
16346 pub use {
16347 crate::vk::KHR_MAINTENANCE5_NAME as NAME,
16348 crate::vk::KHR_MAINTENANCE5_SPEC_VERSION as SPEC_VERSION,
16349 };
16350 #[doc = "VK_KHR_maintenance5 device-level functions"]
16351 #[derive(Clone)]
16352 pub struct Device {
16353 pub(crate) fp: DeviceFn,
16354 pub(crate) handle: crate::vk::Device,
16355 }
16356 impl Device {
16357 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16358 let handle = device.handle();
16359 let fp = DeviceFn::load(|name| unsafe {
16360 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16361 });
16362 Self { handle, fp }
16363 }
16364 #[inline]
16365 pub fn fp(&self) -> &DeviceFn {
16366 &self.fp
16367 }
16368 #[inline]
16369 pub fn device(&self) -> crate::vk::Device {
16370 self.handle
16371 }
16372 }
16373 #[derive(Clone)]
16374 #[doc = "Raw VK_KHR_maintenance5 device-level function pointers"]
16375 pub struct DeviceFn {
16376 pub cmd_bind_index_buffer2_khr: PFN_vkCmdBindIndexBuffer2KHR,
16377 pub get_rendering_area_granularity_khr: PFN_vkGetRenderingAreaGranularityKHR,
16378 pub get_device_image_subresource_layout_khr: PFN_vkGetDeviceImageSubresourceLayoutKHR,
16379 pub get_image_subresource_layout2_khr: PFN_vkGetImageSubresourceLayout2KHR,
16380 }
16381 unsafe impl Send for DeviceFn {}
16382 unsafe impl Sync for DeviceFn {}
16383 impl DeviceFn {
16384 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16385 Self::load_erased(&mut f)
16386 }
16387 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16388 Self {
16389 cmd_bind_index_buffer2_khr: unsafe {
16390 unsafe extern "system" fn cmd_bind_index_buffer2_khr(
16391 _command_buffer: CommandBuffer,
16392 _buffer: Buffer,
16393 _offset: DeviceSize,
16394 _size: DeviceSize,
16395 _index_type: IndexType,
16396 ) {
16397 panic!(concat!(
16398 "Unable to load ",
16399 stringify!(cmd_bind_index_buffer2_khr)
16400 ))
16401 }
16402 let cname =
16403 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer2KHR\0");
16404 let val = _f(cname);
16405 if val.is_null() {
16406 cmd_bind_index_buffer2_khr
16407 } else {
16408 ::core::mem::transmute(val)
16409 }
16410 },
16411 get_rendering_area_granularity_khr: unsafe {
16412 unsafe extern "system" fn get_rendering_area_granularity_khr(
16413 _device: crate::vk::Device,
16414 _p_rendering_area_info: *const RenderingAreaInfoKHR<'_>,
16415 _p_granularity: *mut Extent2D,
16416 ) {
16417 panic!(concat!(
16418 "Unable to load ",
16419 stringify!(get_rendering_area_granularity_khr)
16420 ))
16421 }
16422 let cname = CStr::from_bytes_with_nul_unchecked(
16423 b"vkGetRenderingAreaGranularityKHR\0",
16424 );
16425 let val = _f(cname);
16426 if val.is_null() {
16427 get_rendering_area_granularity_khr
16428 } else {
16429 ::core::mem::transmute(val)
16430 }
16431 },
16432 get_device_image_subresource_layout_khr: unsafe {
16433 unsafe extern "system" fn get_device_image_subresource_layout_khr(
16434 _device: crate::vk::Device,
16435 _p_info: *const DeviceImageSubresourceInfoKHR<'_>,
16436 _p_layout: *mut SubresourceLayout2KHR<'_>,
16437 ) {
16438 panic!(concat!(
16439 "Unable to load ",
16440 stringify!(get_device_image_subresource_layout_khr)
16441 ))
16442 }
16443 let cname = CStr::from_bytes_with_nul_unchecked(
16444 b"vkGetDeviceImageSubresourceLayoutKHR\0",
16445 );
16446 let val = _f(cname);
16447 if val.is_null() {
16448 get_device_image_subresource_layout_khr
16449 } else {
16450 ::core::mem::transmute(val)
16451 }
16452 },
16453 get_image_subresource_layout2_khr: unsafe {
16454 unsafe extern "system" fn get_image_subresource_layout2_khr(
16455 _device: crate::vk::Device,
16456 _image: Image,
16457 _p_subresource: *const ImageSubresource2KHR<'_>,
16458 _p_layout: *mut SubresourceLayout2KHR<'_>,
16459 ) {
16460 panic!(concat!(
16461 "Unable to load ",
16462 stringify!(get_image_subresource_layout2_khr)
16463 ))
16464 }
16465 let cname = CStr::from_bytes_with_nul_unchecked(
16466 b"vkGetImageSubresourceLayout2KHR\0",
16467 );
16468 let val = _f(cname);
16469 if val.is_null() {
16470 get_image_subresource_layout2_khr
16471 } else {
16472 ::core::mem::transmute(val)
16473 }
16474 },
16475 }
16476 }
16477 }
16478 }
16479 #[doc = "VK_KHR_ray_tracing_position_fetch"]
16480 pub mod ray_tracing_position_fetch {
16481 use super::super::*;
16482 pub use {
16483 crate::vk::KHR_RAY_TRACING_POSITION_FETCH_NAME as NAME,
16484 crate::vk::KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION as SPEC_VERSION,
16485 };
16486 }
16487 #[doc = "VK_KHR_cooperative_matrix"]
16488 pub mod cooperative_matrix {
16489 use super::super::*;
16490 pub use {
16491 crate::vk::KHR_COOPERATIVE_MATRIX_NAME as NAME,
16492 crate::vk::KHR_COOPERATIVE_MATRIX_SPEC_VERSION as SPEC_VERSION,
16493 };
16494 #[doc = "VK_KHR_cooperative_matrix instance-level functions"]
16495 #[derive(Clone)]
16496 pub struct Instance {
16497 pub(crate) fp: InstanceFn,
16498 pub(crate) handle: crate::vk::Instance,
16499 }
16500 impl Instance {
16501 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
16502 let handle = instance.handle();
16503 let fp = InstanceFn::load(|name| unsafe {
16504 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
16505 });
16506 Self { handle, fp }
16507 }
16508 #[inline]
16509 pub fn fp(&self) -> &InstanceFn {
16510 &self.fp
16511 }
16512 #[inline]
16513 pub fn instance(&self) -> crate::vk::Instance {
16514 self.handle
16515 }
16516 }
16517 #[derive(Clone)]
16518 #[doc = "Raw VK_KHR_cooperative_matrix instance-level function pointers"]
16519 pub struct InstanceFn {
16520 pub get_physical_device_cooperative_matrix_properties_khr:
16521 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
16522 }
16523 unsafe impl Send for InstanceFn {}
16524 unsafe impl Sync for InstanceFn {}
16525 impl InstanceFn {
16526 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16527 Self::load_erased(&mut f)
16528 }
16529 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16530 Self {
16531 get_physical_device_cooperative_matrix_properties_khr: unsafe {
16532 unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_khr(
16533 _physical_device: PhysicalDevice,
16534 _p_property_count: *mut u32,
16535 _p_properties: *mut CooperativeMatrixPropertiesKHR<'_>,
16536 ) -> Result {
16537 panic!(concat!(
16538 "Unable to load ",
16539 stringify!(get_physical_device_cooperative_matrix_properties_khr)
16540 ))
16541 }
16542 let cname = CStr::from_bytes_with_nul_unchecked(
16543 b"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR\0",
16544 );
16545 let val = _f(cname);
16546 if val.is_null() {
16547 get_physical_device_cooperative_matrix_properties_khr
16548 } else {
16549 ::core::mem::transmute(val)
16550 }
16551 },
16552 }
16553 }
16554 }
16555 }
16556 #[doc = "VK_KHR_video_decode_av1"]
16557 pub mod video_decode_av1 {
16558 use super::super::*;
16559 pub use {
16560 crate::vk::KHR_VIDEO_DECODE_AV1_NAME as NAME,
16561 crate::vk::KHR_VIDEO_DECODE_AV1_SPEC_VERSION as SPEC_VERSION,
16562 };
16563 }
16564 #[doc = "VK_KHR_video_maintenance1"]
16565 pub mod video_maintenance1 {
16566 use super::super::*;
16567 pub use {
16568 crate::vk::KHR_VIDEO_MAINTENANCE1_NAME as NAME,
16569 crate::vk::KHR_VIDEO_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
16570 };
16571 }
16572 #[doc = "VK_KHR_vertex_attribute_divisor"]
16573 pub mod vertex_attribute_divisor {
16574 use super::super::*;
16575 pub use {
16576 crate::vk::KHR_VERTEX_ATTRIBUTE_DIVISOR_NAME as NAME,
16577 crate::vk::KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION as SPEC_VERSION,
16578 };
16579 }
16580 #[doc = "VK_KHR_load_store_op_none"]
16581 pub mod load_store_op_none {
16582 use super::super::*;
16583 pub use {
16584 crate::vk::KHR_LOAD_STORE_OP_NONE_NAME as NAME,
16585 crate::vk::KHR_LOAD_STORE_OP_NONE_SPEC_VERSION as SPEC_VERSION,
16586 };
16587 }
16588 #[doc = "VK_KHR_shader_float_controls2"]
16589 pub mod shader_float_controls2 {
16590 use super::super::*;
16591 pub use {
16592 crate::vk::KHR_SHADER_FLOAT_CONTROLS2_NAME as NAME,
16593 crate::vk::KHR_SHADER_FLOAT_CONTROLS2_SPEC_VERSION as SPEC_VERSION,
16594 };
16595 }
16596 #[doc = "VK_KHR_index_type_uint8"]
16597 pub mod index_type_uint8 {
16598 use super::super::*;
16599 pub use {
16600 crate::vk::KHR_INDEX_TYPE_UINT8_NAME as NAME,
16601 crate::vk::KHR_INDEX_TYPE_UINT8_SPEC_VERSION as SPEC_VERSION,
16602 };
16603 }
16604 #[doc = "VK_KHR_line_rasterization"]
16605 pub mod line_rasterization {
16606 use super::super::*;
16607 pub use {
16608 crate::vk::KHR_LINE_RASTERIZATION_NAME as NAME,
16609 crate::vk::KHR_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
16610 };
16611 #[doc = "VK_KHR_line_rasterization device-level functions"]
16612 #[derive(Clone)]
16613 pub struct Device {
16614 pub(crate) fp: DeviceFn,
16615 pub(crate) handle: crate::vk::Device,
16616 }
16617 impl Device {
16618 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16619 let handle = device.handle();
16620 let fp = DeviceFn::load(|name| unsafe {
16621 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16622 });
16623 Self { handle, fp }
16624 }
16625 #[inline]
16626 pub fn fp(&self) -> &DeviceFn {
16627 &self.fp
16628 }
16629 #[inline]
16630 pub fn device(&self) -> crate::vk::Device {
16631 self.handle
16632 }
16633 }
16634 #[derive(Clone)]
16635 #[doc = "Raw VK_KHR_line_rasterization device-level function pointers"]
16636 pub struct DeviceFn {
16637 pub cmd_set_line_stipple_khr: PFN_vkCmdSetLineStippleKHR,
16638 }
16639 unsafe impl Send for DeviceFn {}
16640 unsafe impl Sync for DeviceFn {}
16641 impl DeviceFn {
16642 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16643 Self::load_erased(&mut f)
16644 }
16645 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16646 Self {
16647 cmd_set_line_stipple_khr: unsafe {
16648 unsafe extern "system" fn cmd_set_line_stipple_khr(
16649 _command_buffer: CommandBuffer,
16650 _line_stipple_factor: u32,
16651 _line_stipple_pattern: u16,
16652 ) {
16653 panic!(concat!(
16654 "Unable to load ",
16655 stringify!(cmd_set_line_stipple_khr)
16656 ))
16657 }
16658 let cname =
16659 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleKHR\0");
16660 let val = _f(cname);
16661 if val.is_null() {
16662 cmd_set_line_stipple_khr
16663 } else {
16664 ::core::mem::transmute(val)
16665 }
16666 },
16667 }
16668 }
16669 }
16670 }
16671 #[doc = "VK_KHR_calibrated_timestamps"]
16672 pub mod calibrated_timestamps {
16673 use super::super::*;
16674 pub use {
16675 crate::vk::KHR_CALIBRATED_TIMESTAMPS_NAME as NAME,
16676 crate::vk::KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION as SPEC_VERSION,
16677 };
16678 #[doc = "VK_KHR_calibrated_timestamps instance-level functions"]
16679 #[derive(Clone)]
16680 pub struct Instance {
16681 pub(crate) fp: InstanceFn,
16682 pub(crate) handle: crate::vk::Instance,
16683 }
16684 impl Instance {
16685 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
16686 let handle = instance.handle();
16687 let fp = InstanceFn::load(|name| unsafe {
16688 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
16689 });
16690 Self { handle, fp }
16691 }
16692 #[inline]
16693 pub fn fp(&self) -> &InstanceFn {
16694 &self.fp
16695 }
16696 #[inline]
16697 pub fn instance(&self) -> crate::vk::Instance {
16698 self.handle
16699 }
16700 }
16701 #[derive(Clone)]
16702 #[doc = "Raw VK_KHR_calibrated_timestamps instance-level function pointers"]
16703 pub struct InstanceFn {
16704 pub get_physical_device_calibrateable_time_domains_khr:
16705 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR,
16706 }
16707 unsafe impl Send for InstanceFn {}
16708 unsafe impl Sync for InstanceFn {}
16709 impl InstanceFn {
16710 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16711 Self::load_erased(&mut f)
16712 }
16713 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16714 Self {
16715 get_physical_device_calibrateable_time_domains_khr: unsafe {
16716 unsafe extern "system" fn get_physical_device_calibrateable_time_domains_khr(
16717 _physical_device: PhysicalDevice,
16718 _p_time_domain_count: *mut u32,
16719 _p_time_domains: *mut TimeDomainKHR,
16720 ) -> Result {
16721 panic!(concat!(
16722 "Unable to load ",
16723 stringify!(get_physical_device_calibrateable_time_domains_khr)
16724 ))
16725 }
16726 let cname = CStr::from_bytes_with_nul_unchecked(
16727 b"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR\0",
16728 );
16729 let val = _f(cname);
16730 if val.is_null() {
16731 get_physical_device_calibrateable_time_domains_khr
16732 } else {
16733 ::core::mem::transmute(val)
16734 }
16735 },
16736 }
16737 }
16738 }
16739 #[doc = "VK_KHR_calibrated_timestamps device-level functions"]
16740 #[derive(Clone)]
16741 pub struct Device {
16742 pub(crate) fp: DeviceFn,
16743 pub(crate) handle: crate::vk::Device,
16744 }
16745 impl Device {
16746 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16747 let handle = device.handle();
16748 let fp = DeviceFn::load(|name| unsafe {
16749 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16750 });
16751 Self { handle, fp }
16752 }
16753 #[inline]
16754 pub fn fp(&self) -> &DeviceFn {
16755 &self.fp
16756 }
16757 #[inline]
16758 pub fn device(&self) -> crate::vk::Device {
16759 self.handle
16760 }
16761 }
16762 #[derive(Clone)]
16763 #[doc = "Raw VK_KHR_calibrated_timestamps device-level function pointers"]
16764 pub struct DeviceFn {
16765 pub get_calibrated_timestamps_khr: PFN_vkGetCalibratedTimestampsKHR,
16766 }
16767 unsafe impl Send for DeviceFn {}
16768 unsafe impl Sync for DeviceFn {}
16769 impl DeviceFn {
16770 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16771 Self::load_erased(&mut f)
16772 }
16773 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16774 Self {
16775 get_calibrated_timestamps_khr: unsafe {
16776 unsafe extern "system" fn get_calibrated_timestamps_khr(
16777 _device: crate::vk::Device,
16778 _timestamp_count: u32,
16779 _p_timestamp_infos: *const CalibratedTimestampInfoKHR<'_>,
16780 _p_timestamps: *mut u64,
16781 _p_max_deviation: *mut u64,
16782 ) -> Result {
16783 panic!(concat!(
16784 "Unable to load ",
16785 stringify!(get_calibrated_timestamps_khr)
16786 ))
16787 }
16788 let cname =
16789 CStr::from_bytes_with_nul_unchecked(b"vkGetCalibratedTimestampsKHR\0");
16790 let val = _f(cname);
16791 if val.is_null() {
16792 get_calibrated_timestamps_khr
16793 } else {
16794 ::core::mem::transmute(val)
16795 }
16796 },
16797 }
16798 }
16799 }
16800 }
16801 #[doc = "VK_KHR_shader_expect_assume"]
16802 pub mod shader_expect_assume {
16803 use super::super::*;
16804 pub use {
16805 crate::vk::KHR_SHADER_EXPECT_ASSUME_NAME as NAME,
16806 crate::vk::KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION as SPEC_VERSION,
16807 };
16808 }
16809 #[doc = "VK_KHR_maintenance6"]
16810 pub mod maintenance6 {
16811 use super::super::*;
16812 pub use {
16813 crate::vk::KHR_MAINTENANCE6_NAME as NAME,
16814 crate::vk::KHR_MAINTENANCE6_SPEC_VERSION as SPEC_VERSION,
16815 };
16816 #[doc = "VK_KHR_maintenance6 device-level functions"]
16817 #[derive(Clone)]
16818 pub struct Device {
16819 pub(crate) fp: DeviceFn,
16820 pub(crate) handle: crate::vk::Device,
16821 }
16822 impl Device {
16823 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
16824 let handle = device.handle();
16825 let fp = DeviceFn::load(|name| unsafe {
16826 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
16827 });
16828 Self { handle, fp }
16829 }
16830 #[inline]
16831 pub fn fp(&self) -> &DeviceFn {
16832 &self.fp
16833 }
16834 #[inline]
16835 pub fn device(&self) -> crate::vk::Device {
16836 self.handle
16837 }
16838 }
16839 #[derive(Clone)]
16840 #[doc = "Raw VK_KHR_maintenance6 device-level function pointers"]
16841 pub struct DeviceFn {
16842 pub cmd_bind_descriptor_sets2_khr: PFN_vkCmdBindDescriptorSets2KHR,
16843 pub cmd_push_constants2_khr: PFN_vkCmdPushConstants2KHR,
16844 pub cmd_push_descriptor_set2_khr: PFN_vkCmdPushDescriptorSet2KHR,
16845 pub cmd_push_descriptor_set_with_template2_khr:
16846 PFN_vkCmdPushDescriptorSetWithTemplate2KHR,
16847 pub cmd_set_descriptor_buffer_offsets2_ext: PFN_vkCmdSetDescriptorBufferOffsets2EXT,
16848 pub cmd_bind_descriptor_buffer_embedded_samplers2_ext:
16849 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT,
16850 }
16851 unsafe impl Send for DeviceFn {}
16852 unsafe impl Sync for DeviceFn {}
16853 impl DeviceFn {
16854 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
16855 Self::load_erased(&mut f)
16856 }
16857 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
16858 Self {
16859 cmd_bind_descriptor_sets2_khr: unsafe {
16860 unsafe extern "system" fn cmd_bind_descriptor_sets2_khr(
16861 _command_buffer: CommandBuffer,
16862 _p_bind_descriptor_sets_info: *const BindDescriptorSetsInfoKHR<'_>,
16863 ) {
16864 panic!(concat!(
16865 "Unable to load ",
16866 stringify!(cmd_bind_descriptor_sets2_khr)
16867 ))
16868 }
16869 let cname =
16870 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets2KHR\0");
16871 let val = _f(cname);
16872 if val.is_null() {
16873 cmd_bind_descriptor_sets2_khr
16874 } else {
16875 ::core::mem::transmute(val)
16876 }
16877 },
16878 cmd_push_constants2_khr: unsafe {
16879 unsafe extern "system" fn cmd_push_constants2_khr(
16880 _command_buffer: CommandBuffer,
16881 _p_push_constants_info: *const PushConstantsInfoKHR<'_>,
16882 ) {
16883 panic!(concat!(
16884 "Unable to load ",
16885 stringify!(cmd_push_constants2_khr)
16886 ))
16887 }
16888 let cname =
16889 CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants2KHR\0");
16890 let val = _f(cname);
16891 if val.is_null() {
16892 cmd_push_constants2_khr
16893 } else {
16894 ::core::mem::transmute(val)
16895 }
16896 },
16897 cmd_push_descriptor_set2_khr: unsafe {
16898 unsafe extern "system" fn cmd_push_descriptor_set2_khr(
16899 _command_buffer: CommandBuffer,
16900 _p_push_descriptor_set_info: *const PushDescriptorSetInfoKHR<'_>,
16901 ) {
16902 panic!(concat!(
16903 "Unable to load ",
16904 stringify!(cmd_push_descriptor_set2_khr)
16905 ))
16906 }
16907 let cname =
16908 CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSet2KHR\0");
16909 let val = _f(cname);
16910 if val.is_null() {
16911 cmd_push_descriptor_set2_khr
16912 } else {
16913 ::core::mem::transmute(val)
16914 }
16915 },
16916 cmd_push_descriptor_set_with_template2_khr: unsafe {
16917 unsafe extern "system" fn cmd_push_descriptor_set_with_template2_khr(
16918 _command_buffer: CommandBuffer,
16919 _p_push_descriptor_set_with_template_info : * const PushDescriptorSetWithTemplateInfoKHR < '_ >,
16920 ) {
16921 panic!(concat!(
16922 "Unable to load ",
16923 stringify!(cmd_push_descriptor_set_with_template2_khr)
16924 ))
16925 }
16926 let cname = CStr::from_bytes_with_nul_unchecked(
16927 b"vkCmdPushDescriptorSetWithTemplate2KHR\0",
16928 );
16929 let val = _f(cname);
16930 if val.is_null() {
16931 cmd_push_descriptor_set_with_template2_khr
16932 } else {
16933 ::core::mem::transmute(val)
16934 }
16935 },
16936 cmd_set_descriptor_buffer_offsets2_ext: unsafe {
16937 unsafe extern "system" fn cmd_set_descriptor_buffer_offsets2_ext(
16938 _command_buffer: CommandBuffer,
16939 _p_set_descriptor_buffer_offsets_info : * const SetDescriptorBufferOffsetsInfoEXT < '_ >,
16940 ) {
16941 panic!(concat!(
16942 "Unable to load ",
16943 stringify!(cmd_set_descriptor_buffer_offsets2_ext)
16944 ))
16945 }
16946 let cname = CStr::from_bytes_with_nul_unchecked(
16947 b"vkCmdSetDescriptorBufferOffsets2EXT\0",
16948 );
16949 let val = _f(cname);
16950 if val.is_null() {
16951 cmd_set_descriptor_buffer_offsets2_ext
16952 } else {
16953 ::core::mem::transmute(val)
16954 }
16955 },
16956 cmd_bind_descriptor_buffer_embedded_samplers2_ext: unsafe {
16957 unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers2_ext(
16958 _command_buffer: CommandBuffer,
16959 _p_bind_descriptor_buffer_embedded_samplers_info : * const BindDescriptorBufferEmbeddedSamplersInfoEXT < '_ >,
16960 ) {
16961 panic!(concat!(
16962 "Unable to load ",
16963 stringify!(cmd_bind_descriptor_buffer_embedded_samplers2_ext)
16964 ))
16965 }
16966 let cname = CStr::from_bytes_with_nul_unchecked(
16967 b"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT\0",
16968 );
16969 let val = _f(cname);
16970 if val.is_null() {
16971 cmd_bind_descriptor_buffer_embedded_samplers2_ext
16972 } else {
16973 ::core::mem::transmute(val)
16974 }
16975 },
16976 }
16977 }
16978 }
16979 }
16980}
16981#[doc = "Extensions tagged LUNARG"]
16982pub mod lunarg {
16983 #[doc = "VK_LUNARG_direct_driver_loading"]
16984 pub mod direct_driver_loading {
16985 use super::super::*;
16986 pub use {
16987 crate::vk::LUNARG_DIRECT_DRIVER_LOADING_NAME as NAME,
16988 crate::vk::LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION as SPEC_VERSION,
16989 };
16990 }
16991}
16992#[doc = "Extensions tagged MSFT"]
16993pub mod msft {
16994 #[doc = "VK_MSFT_layered_driver"]
16995 pub mod layered_driver {
16996 use super::super::*;
16997 pub use {
16998 crate::vk::MSFT_LAYERED_DRIVER_NAME as NAME,
16999 crate::vk::MSFT_LAYERED_DRIVER_SPEC_VERSION as SPEC_VERSION,
17000 };
17001 }
17002}
17003#[doc = "Extensions tagged MVK"]
17004pub mod mvk {
17005 #[doc = "VK_MVK_ios_surface"]
17006 pub mod ios_surface {
17007 use super::super::*;
17008 pub use {
17009 crate::vk::MVK_IOS_SURFACE_NAME as NAME,
17010 crate::vk::MVK_IOS_SURFACE_SPEC_VERSION as SPEC_VERSION,
17011 };
17012 #[doc = "VK_MVK_ios_surface instance-level functions"]
17013 #[derive(Clone)]
17014 pub struct Instance {
17015 pub(crate) fp: InstanceFn,
17016 pub(crate) handle: crate::vk::Instance,
17017 }
17018 impl Instance {
17019 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
17020 let handle = instance.handle();
17021 let fp = InstanceFn::load(|name| unsafe {
17022 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
17023 });
17024 Self { handle, fp }
17025 }
17026 #[inline]
17027 pub fn fp(&self) -> &InstanceFn {
17028 &self.fp
17029 }
17030 #[inline]
17031 pub fn instance(&self) -> crate::vk::Instance {
17032 self.handle
17033 }
17034 }
17035 #[derive(Clone)]
17036 #[doc = "Raw VK_MVK_ios_surface instance-level function pointers"]
17037 pub struct InstanceFn {
17038 pub create_ios_surface_mvk: PFN_vkCreateIOSSurfaceMVK,
17039 }
17040 unsafe impl Send for InstanceFn {}
17041 unsafe impl Sync for InstanceFn {}
17042 impl InstanceFn {
17043 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17044 Self::load_erased(&mut f)
17045 }
17046 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17047 Self {
17048 create_ios_surface_mvk: unsafe {
17049 unsafe extern "system" fn create_ios_surface_mvk(
17050 _instance: crate::vk::Instance,
17051 _p_create_info: *const IOSSurfaceCreateInfoMVK<'_>,
17052 _p_allocator: *const AllocationCallbacks<'_>,
17053 _p_surface: *mut SurfaceKHR,
17054 ) -> Result {
17055 panic!(concat!(
17056 "Unable to load ",
17057 stringify!(create_ios_surface_mvk)
17058 ))
17059 }
17060 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateIOSSurfaceMVK\0");
17061 let val = _f(cname);
17062 if val.is_null() {
17063 create_ios_surface_mvk
17064 } else {
17065 ::core::mem::transmute(val)
17066 }
17067 },
17068 }
17069 }
17070 }
17071 }
17072 #[doc = "VK_MVK_macos_surface"]
17073 pub mod macos_surface {
17074 use super::super::*;
17075 pub use {
17076 crate::vk::MVK_MACOS_SURFACE_NAME as NAME,
17077 crate::vk::MVK_MACOS_SURFACE_SPEC_VERSION as SPEC_VERSION,
17078 };
17079 #[doc = "VK_MVK_macos_surface instance-level functions"]
17080 #[derive(Clone)]
17081 pub struct Instance {
17082 pub(crate) fp: InstanceFn,
17083 pub(crate) handle: crate::vk::Instance,
17084 }
17085 impl Instance {
17086 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
17087 let handle = instance.handle();
17088 let fp = InstanceFn::load(|name| unsafe {
17089 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
17090 });
17091 Self { handle, fp }
17092 }
17093 #[inline]
17094 pub fn fp(&self) -> &InstanceFn {
17095 &self.fp
17096 }
17097 #[inline]
17098 pub fn instance(&self) -> crate::vk::Instance {
17099 self.handle
17100 }
17101 }
17102 #[derive(Clone)]
17103 #[doc = "Raw VK_MVK_macos_surface instance-level function pointers"]
17104 pub struct InstanceFn {
17105 pub create_mac_os_surface_mvk: PFN_vkCreateMacOSSurfaceMVK,
17106 }
17107 unsafe impl Send for InstanceFn {}
17108 unsafe impl Sync for InstanceFn {}
17109 impl InstanceFn {
17110 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17111 Self::load_erased(&mut f)
17112 }
17113 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17114 Self {
17115 create_mac_os_surface_mvk: unsafe {
17116 unsafe extern "system" fn create_mac_os_surface_mvk(
17117 _instance: crate::vk::Instance,
17118 _p_create_info: *const MacOSSurfaceCreateInfoMVK<'_>,
17119 _p_allocator: *const AllocationCallbacks<'_>,
17120 _p_surface: *mut SurfaceKHR,
17121 ) -> Result {
17122 panic!(concat!(
17123 "Unable to load ",
17124 stringify!(create_mac_os_surface_mvk)
17125 ))
17126 }
17127 let cname =
17128 CStr::from_bytes_with_nul_unchecked(b"vkCreateMacOSSurfaceMVK\0");
17129 let val = _f(cname);
17130 if val.is_null() {
17131 create_mac_os_surface_mvk
17132 } else {
17133 ::core::mem::transmute(val)
17134 }
17135 },
17136 }
17137 }
17138 }
17139 }
17140}
17141#[doc = "Extensions tagged NN"]
17142pub mod nn {
17143 #[doc = "VK_NN_vi_surface"]
17144 pub mod vi_surface {
17145 use super::super::*;
17146 pub use {
17147 crate::vk::NN_VI_SURFACE_NAME as NAME,
17148 crate::vk::NN_VI_SURFACE_SPEC_VERSION as SPEC_VERSION,
17149 };
17150 #[doc = "VK_NN_vi_surface instance-level functions"]
17151 #[derive(Clone)]
17152 pub struct Instance {
17153 pub(crate) fp: InstanceFn,
17154 pub(crate) handle: crate::vk::Instance,
17155 }
17156 impl Instance {
17157 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
17158 let handle = instance.handle();
17159 let fp = InstanceFn::load(|name| unsafe {
17160 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
17161 });
17162 Self { handle, fp }
17163 }
17164 #[inline]
17165 pub fn fp(&self) -> &InstanceFn {
17166 &self.fp
17167 }
17168 #[inline]
17169 pub fn instance(&self) -> crate::vk::Instance {
17170 self.handle
17171 }
17172 }
17173 #[derive(Clone)]
17174 #[doc = "Raw VK_NN_vi_surface instance-level function pointers"]
17175 pub struct InstanceFn {
17176 pub create_vi_surface_nn: PFN_vkCreateViSurfaceNN,
17177 }
17178 unsafe impl Send for InstanceFn {}
17179 unsafe impl Sync for InstanceFn {}
17180 impl InstanceFn {
17181 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17182 Self::load_erased(&mut f)
17183 }
17184 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17185 Self {
17186 create_vi_surface_nn: unsafe {
17187 unsafe extern "system" fn create_vi_surface_nn(
17188 _instance: crate::vk::Instance,
17189 _p_create_info: *const ViSurfaceCreateInfoNN<'_>,
17190 _p_allocator: *const AllocationCallbacks<'_>,
17191 _p_surface: *mut SurfaceKHR,
17192 ) -> Result {
17193 panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn)))
17194 }
17195 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateViSurfaceNN\0");
17196 let val = _f(cname);
17197 if val.is_null() {
17198 create_vi_surface_nn
17199 } else {
17200 ::core::mem::transmute(val)
17201 }
17202 },
17203 }
17204 }
17205 }
17206 }
17207}
17208#[doc = "Extensions tagged NV"]
17209pub mod nv {
17210 #[doc = "VK_NV_glsl_shader"]
17211 pub mod glsl_shader {
17212 use super::super::*;
17213 pub use {
17214 crate::vk::NV_GLSL_SHADER_NAME as NAME,
17215 crate::vk::NV_GLSL_SHADER_SPEC_VERSION as SPEC_VERSION,
17216 };
17217 }
17218 #[doc = "VK_NV_dedicated_allocation"]
17219 pub mod dedicated_allocation {
17220 use super::super::*;
17221 pub use {
17222 crate::vk::NV_DEDICATED_ALLOCATION_NAME as NAME,
17223 crate::vk::NV_DEDICATED_ALLOCATION_SPEC_VERSION as SPEC_VERSION,
17224 };
17225 }
17226 #[doc = "VK_NV_corner_sampled_image"]
17227 pub mod corner_sampled_image {
17228 use super::super::*;
17229 pub use {
17230 crate::vk::NV_CORNER_SAMPLED_IMAGE_NAME as NAME,
17231 crate::vk::NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION as SPEC_VERSION,
17232 };
17233 }
17234 #[doc = "VK_NV_external_memory_capabilities"]
17235 pub mod external_memory_capabilities {
17236 use super::super::*;
17237 pub use {
17238 crate::vk::NV_EXTERNAL_MEMORY_CAPABILITIES_NAME as NAME,
17239 crate::vk::NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION as SPEC_VERSION,
17240 };
17241 #[doc = "VK_NV_external_memory_capabilities instance-level functions"]
17242 #[derive(Clone)]
17243 pub struct Instance {
17244 pub(crate) fp: InstanceFn,
17245 pub(crate) handle: crate::vk::Instance,
17246 }
17247 impl Instance {
17248 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
17249 let handle = instance.handle();
17250 let fp = InstanceFn::load(|name| unsafe {
17251 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
17252 });
17253 Self { handle, fp }
17254 }
17255 #[inline]
17256 pub fn fp(&self) -> &InstanceFn {
17257 &self.fp
17258 }
17259 #[inline]
17260 pub fn instance(&self) -> crate::vk::Instance {
17261 self.handle
17262 }
17263 }
17264 #[derive(Clone)]
17265 #[doc = "Raw VK_NV_external_memory_capabilities instance-level function pointers"]
17266 pub struct InstanceFn {
17267 pub get_physical_device_external_image_format_properties_nv:
17268 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
17269 }
17270 unsafe impl Send for InstanceFn {}
17271 unsafe impl Sync for InstanceFn {}
17272 impl InstanceFn {
17273 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17274 Self::load_erased(&mut f)
17275 }
17276 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17277 Self {
17278 get_physical_device_external_image_format_properties_nv: unsafe {
17279 unsafe extern "system" fn get_physical_device_external_image_format_properties_nv(
17280 _physical_device: PhysicalDevice,
17281 _format: Format,
17282 _ty: ImageType,
17283 _tiling: ImageTiling,
17284 _usage: ImageUsageFlags,
17285 _flags: ImageCreateFlags,
17286 _external_handle_type: ExternalMemoryHandleTypeFlagsNV,
17287 _p_external_image_format_properties : * mut ExternalImageFormatPropertiesNV,
17288 ) -> Result {
17289 panic!(concat!(
17290 "Unable to load ",
17291 stringify!(get_physical_device_external_image_format_properties_nv)
17292 ))
17293 }
17294 let cname = CStr::from_bytes_with_nul_unchecked(
17295 b"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\0",
17296 );
17297 let val = _f(cname);
17298 if val.is_null() {
17299 get_physical_device_external_image_format_properties_nv
17300 } else {
17301 ::core::mem::transmute(val)
17302 }
17303 },
17304 }
17305 }
17306 }
17307 }
17308 #[doc = "VK_NV_external_memory"]
17309 pub mod external_memory {
17310 use super::super::*;
17311 pub use {
17312 crate::vk::NV_EXTERNAL_MEMORY_NAME as NAME,
17313 crate::vk::NV_EXTERNAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
17314 };
17315 }
17316 #[doc = "VK_NV_external_memory_win32"]
17317 pub mod external_memory_win32 {
17318 use super::super::*;
17319 pub use {
17320 crate::vk::NV_EXTERNAL_MEMORY_WIN32_NAME as NAME,
17321 crate::vk::NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION as SPEC_VERSION,
17322 };
17323 #[doc = "VK_NV_external_memory_win32 device-level functions"]
17324 #[derive(Clone)]
17325 pub struct Device {
17326 pub(crate) fp: DeviceFn,
17327 pub(crate) handle: crate::vk::Device,
17328 }
17329 impl Device {
17330 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
17331 let handle = device.handle();
17332 let fp = DeviceFn::load(|name| unsafe {
17333 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
17334 });
17335 Self { handle, fp }
17336 }
17337 #[inline]
17338 pub fn fp(&self) -> &DeviceFn {
17339 &self.fp
17340 }
17341 #[inline]
17342 pub fn device(&self) -> crate::vk::Device {
17343 self.handle
17344 }
17345 }
17346 #[derive(Clone)]
17347 #[doc = "Raw VK_NV_external_memory_win32 device-level function pointers"]
17348 pub struct DeviceFn {
17349 pub get_memory_win32_handle_nv: PFN_vkGetMemoryWin32HandleNV,
17350 }
17351 unsafe impl Send for DeviceFn {}
17352 unsafe impl Sync for DeviceFn {}
17353 impl DeviceFn {
17354 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17355 Self::load_erased(&mut f)
17356 }
17357 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17358 Self {
17359 get_memory_win32_handle_nv: unsafe {
17360 unsafe extern "system" fn get_memory_win32_handle_nv(
17361 _device: crate::vk::Device,
17362 _memory: DeviceMemory,
17363 _handle_type: ExternalMemoryHandleTypeFlagsNV,
17364 _p_handle: *mut HANDLE,
17365 ) -> Result {
17366 panic!(concat!(
17367 "Unable to load ",
17368 stringify!(get_memory_win32_handle_nv)
17369 ))
17370 }
17371 let cname =
17372 CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleNV\0");
17373 let val = _f(cname);
17374 if val.is_null() {
17375 get_memory_win32_handle_nv
17376 } else {
17377 ::core::mem::transmute(val)
17378 }
17379 },
17380 }
17381 }
17382 }
17383 }
17384 #[doc = "VK_NV_win32_keyed_mutex"]
17385 pub mod win32_keyed_mutex {
17386 use super::super::*;
17387 pub use {
17388 crate::vk::NV_WIN32_KEYED_MUTEX_NAME as NAME,
17389 crate::vk::NV_WIN32_KEYED_MUTEX_SPEC_VERSION as SPEC_VERSION,
17390 };
17391 }
17392 #[doc = "VK_NV_clip_space_w_scaling"]
17393 pub mod clip_space_w_scaling {
17394 use super::super::*;
17395 pub use {
17396 crate::vk::NV_CLIP_SPACE_W_SCALING_NAME as NAME,
17397 crate::vk::NV_CLIP_SPACE_W_SCALING_SPEC_VERSION as SPEC_VERSION,
17398 };
17399 #[doc = "VK_NV_clip_space_w_scaling device-level functions"]
17400 #[derive(Clone)]
17401 pub struct Device {
17402 pub(crate) fp: DeviceFn,
17403 pub(crate) handle: crate::vk::Device,
17404 }
17405 impl Device {
17406 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
17407 let handle = device.handle();
17408 let fp = DeviceFn::load(|name| unsafe {
17409 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
17410 });
17411 Self { handle, fp }
17412 }
17413 #[inline]
17414 pub fn fp(&self) -> &DeviceFn {
17415 &self.fp
17416 }
17417 #[inline]
17418 pub fn device(&self) -> crate::vk::Device {
17419 self.handle
17420 }
17421 }
17422 #[derive(Clone)]
17423 #[doc = "Raw VK_NV_clip_space_w_scaling device-level function pointers"]
17424 pub struct DeviceFn {
17425 pub cmd_set_viewport_w_scaling_nv: PFN_vkCmdSetViewportWScalingNV,
17426 }
17427 unsafe impl Send for DeviceFn {}
17428 unsafe impl Sync for DeviceFn {}
17429 impl DeviceFn {
17430 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17431 Self::load_erased(&mut f)
17432 }
17433 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17434 Self {
17435 cmd_set_viewport_w_scaling_nv: unsafe {
17436 unsafe extern "system" fn cmd_set_viewport_w_scaling_nv(
17437 _command_buffer: CommandBuffer,
17438 _first_viewport: u32,
17439 _viewport_count: u32,
17440 _p_viewport_w_scalings: *const ViewportWScalingNV,
17441 ) {
17442 panic!(concat!(
17443 "Unable to load ",
17444 stringify!(cmd_set_viewport_w_scaling_nv)
17445 ))
17446 }
17447 let cname =
17448 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWScalingNV\0");
17449 let val = _f(cname);
17450 if val.is_null() {
17451 cmd_set_viewport_w_scaling_nv
17452 } else {
17453 ::core::mem::transmute(val)
17454 }
17455 },
17456 }
17457 }
17458 }
17459 }
17460 #[doc = "VK_NV_sample_mask_override_coverage"]
17461 pub mod sample_mask_override_coverage {
17462 use super::super::*;
17463 pub use {
17464 crate::vk::NV_SAMPLE_MASK_OVERRIDE_COVERAGE_NAME as NAME,
17465 crate::vk::NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION as SPEC_VERSION,
17466 };
17467 }
17468 #[doc = "VK_NV_geometry_shader_passthrough"]
17469 pub mod geometry_shader_passthrough {
17470 use super::super::*;
17471 pub use {
17472 crate::vk::NV_GEOMETRY_SHADER_PASSTHROUGH_NAME as NAME,
17473 crate::vk::NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION as SPEC_VERSION,
17474 };
17475 }
17476 #[doc = "VK_NV_viewport_array2"]
17477 pub mod viewport_array2 {
17478 use super::super::*;
17479 pub use {
17480 crate::vk::NV_VIEWPORT_ARRAY2_NAME as NAME,
17481 crate::vk::NV_VIEWPORT_ARRAY2_SPEC_VERSION as SPEC_VERSION,
17482 };
17483 }
17484 #[doc = "VK_NV_viewport_swizzle"]
17485 pub mod viewport_swizzle {
17486 use super::super::*;
17487 pub use {
17488 crate::vk::NV_VIEWPORT_SWIZZLE_NAME as NAME,
17489 crate::vk::NV_VIEWPORT_SWIZZLE_SPEC_VERSION as SPEC_VERSION,
17490 };
17491 }
17492 #[doc = "VK_NV_fragment_coverage_to_color"]
17493 pub mod fragment_coverage_to_color {
17494 use super::super::*;
17495 pub use {
17496 crate::vk::NV_FRAGMENT_COVERAGE_TO_COLOR_NAME as NAME,
17497 crate::vk::NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION as SPEC_VERSION,
17498 };
17499 }
17500 #[doc = "VK_NV_framebuffer_mixed_samples"]
17501 pub mod framebuffer_mixed_samples {
17502 use super::super::*;
17503 pub use {
17504 crate::vk::NV_FRAMEBUFFER_MIXED_SAMPLES_NAME as NAME,
17505 crate::vk::NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION as SPEC_VERSION,
17506 };
17507 }
17508 #[doc = "VK_NV_fill_rectangle"]
17509 pub mod fill_rectangle {
17510 use super::super::*;
17511 pub use {
17512 crate::vk::NV_FILL_RECTANGLE_NAME as NAME,
17513 crate::vk::NV_FILL_RECTANGLE_SPEC_VERSION as SPEC_VERSION,
17514 };
17515 }
17516 #[doc = "VK_NV_shader_sm_builtins"]
17517 pub mod shader_sm_builtins {
17518 use super::super::*;
17519 pub use {
17520 crate::vk::NV_SHADER_SM_BUILTINS_NAME as NAME,
17521 crate::vk::NV_SHADER_SM_BUILTINS_SPEC_VERSION as SPEC_VERSION,
17522 };
17523 }
17524 #[doc = "VK_NV_shading_rate_image"]
17525 pub mod shading_rate_image {
17526 use super::super::*;
17527 pub use {
17528 crate::vk::NV_SHADING_RATE_IMAGE_NAME as NAME,
17529 crate::vk::NV_SHADING_RATE_IMAGE_SPEC_VERSION as SPEC_VERSION,
17530 };
17531 #[doc = "VK_NV_shading_rate_image device-level functions"]
17532 #[derive(Clone)]
17533 pub struct Device {
17534 pub(crate) fp: DeviceFn,
17535 pub(crate) handle: crate::vk::Device,
17536 }
17537 impl Device {
17538 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
17539 let handle = device.handle();
17540 let fp = DeviceFn::load(|name| unsafe {
17541 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
17542 });
17543 Self { handle, fp }
17544 }
17545 #[inline]
17546 pub fn fp(&self) -> &DeviceFn {
17547 &self.fp
17548 }
17549 #[inline]
17550 pub fn device(&self) -> crate::vk::Device {
17551 self.handle
17552 }
17553 }
17554 #[derive(Clone)]
17555 #[doc = "Raw VK_NV_shading_rate_image device-level function pointers"]
17556 pub struct DeviceFn {
17557 pub cmd_bind_shading_rate_image_nv: PFN_vkCmdBindShadingRateImageNV,
17558 pub cmd_set_viewport_shading_rate_palette_nv: PFN_vkCmdSetViewportShadingRatePaletteNV,
17559 pub cmd_set_coarse_sample_order_nv: PFN_vkCmdSetCoarseSampleOrderNV,
17560 }
17561 unsafe impl Send for DeviceFn {}
17562 unsafe impl Sync for DeviceFn {}
17563 impl DeviceFn {
17564 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17565 Self::load_erased(&mut f)
17566 }
17567 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17568 Self {
17569 cmd_bind_shading_rate_image_nv: unsafe {
17570 unsafe extern "system" fn cmd_bind_shading_rate_image_nv(
17571 _command_buffer: CommandBuffer,
17572 _image_view: ImageView,
17573 _image_layout: ImageLayout,
17574 ) {
17575 panic!(concat!(
17576 "Unable to load ",
17577 stringify!(cmd_bind_shading_rate_image_nv)
17578 ))
17579 }
17580 let cname =
17581 CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadingRateImageNV\0");
17582 let val = _f(cname);
17583 if val.is_null() {
17584 cmd_bind_shading_rate_image_nv
17585 } else {
17586 ::core::mem::transmute(val)
17587 }
17588 },
17589 cmd_set_viewport_shading_rate_palette_nv: unsafe {
17590 unsafe extern "system" fn cmd_set_viewport_shading_rate_palette_nv(
17591 _command_buffer: CommandBuffer,
17592 _first_viewport: u32,
17593 _viewport_count: u32,
17594 _p_shading_rate_palettes: *const ShadingRatePaletteNV<'_>,
17595 ) {
17596 panic!(concat!(
17597 "Unable to load ",
17598 stringify!(cmd_set_viewport_shading_rate_palette_nv)
17599 ))
17600 }
17601 let cname = CStr::from_bytes_with_nul_unchecked(
17602 b"vkCmdSetViewportShadingRatePaletteNV\0",
17603 );
17604 let val = _f(cname);
17605 if val.is_null() {
17606 cmd_set_viewport_shading_rate_palette_nv
17607 } else {
17608 ::core::mem::transmute(val)
17609 }
17610 },
17611 cmd_set_coarse_sample_order_nv: unsafe {
17612 unsafe extern "system" fn cmd_set_coarse_sample_order_nv(
17613 _command_buffer: CommandBuffer,
17614 _sample_order_type: CoarseSampleOrderTypeNV,
17615 _custom_sample_order_count: u32,
17616 _p_custom_sample_orders: *const CoarseSampleOrderCustomNV<'_>,
17617 ) {
17618 panic!(concat!(
17619 "Unable to load ",
17620 stringify!(cmd_set_coarse_sample_order_nv)
17621 ))
17622 }
17623 let cname =
17624 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCoarseSampleOrderNV\0");
17625 let val = _f(cname);
17626 if val.is_null() {
17627 cmd_set_coarse_sample_order_nv
17628 } else {
17629 ::core::mem::transmute(val)
17630 }
17631 },
17632 }
17633 }
17634 }
17635 }
17636 #[doc = "VK_NV_ray_tracing"]
17637 pub mod ray_tracing {
17638 use super::super::*;
17639 pub use {
17640 crate::vk::NV_RAY_TRACING_NAME as NAME,
17641 crate::vk::NV_RAY_TRACING_SPEC_VERSION as SPEC_VERSION,
17642 };
17643 #[doc = "VK_NV_ray_tracing device-level functions"]
17644 #[derive(Clone)]
17645 pub struct Device {
17646 pub(crate) fp: DeviceFn,
17647 pub(crate) handle: crate::vk::Device,
17648 }
17649 impl Device {
17650 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
17651 let handle = device.handle();
17652 let fp = DeviceFn::load(|name| unsafe {
17653 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
17654 });
17655 Self { handle, fp }
17656 }
17657 #[inline]
17658 pub fn fp(&self) -> &DeviceFn {
17659 &self.fp
17660 }
17661 #[inline]
17662 pub fn device(&self) -> crate::vk::Device {
17663 self.handle
17664 }
17665 }
17666 #[derive(Clone)]
17667 #[doc = "Raw VK_NV_ray_tracing device-level function pointers"]
17668 pub struct DeviceFn {
17669 pub create_acceleration_structure_nv: PFN_vkCreateAccelerationStructureNV,
17670 pub destroy_acceleration_structure_nv: PFN_vkDestroyAccelerationStructureNV,
17671 pub get_acceleration_structure_memory_requirements_nv:
17672 PFN_vkGetAccelerationStructureMemoryRequirementsNV,
17673 pub bind_acceleration_structure_memory_nv: PFN_vkBindAccelerationStructureMemoryNV,
17674 pub cmd_build_acceleration_structure_nv: PFN_vkCmdBuildAccelerationStructureNV,
17675 pub cmd_copy_acceleration_structure_nv: PFN_vkCmdCopyAccelerationStructureNV,
17676 pub cmd_trace_rays_nv: PFN_vkCmdTraceRaysNV,
17677 pub create_ray_tracing_pipelines_nv: PFN_vkCreateRayTracingPipelinesNV,
17678 pub get_ray_tracing_shader_group_handles_nv: PFN_vkGetRayTracingShaderGroupHandlesKHR,
17679 pub get_acceleration_structure_handle_nv: PFN_vkGetAccelerationStructureHandleNV,
17680 pub cmd_write_acceleration_structures_properties_nv:
17681 PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
17682 pub compile_deferred_nv: PFN_vkCompileDeferredNV,
17683 }
17684 unsafe impl Send for DeviceFn {}
17685 unsafe impl Sync for DeviceFn {}
17686 impl DeviceFn {
17687 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
17688 Self::load_erased(&mut f)
17689 }
17690 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
17691 Self {
17692 create_acceleration_structure_nv: unsafe {
17693 unsafe extern "system" fn create_acceleration_structure_nv(
17694 _device: crate::vk::Device,
17695 _p_create_info: *const AccelerationStructureCreateInfoNV<'_>,
17696 _p_allocator: *const AllocationCallbacks<'_>,
17697 _p_acceleration_structure: *mut AccelerationStructureNV,
17698 ) -> Result {
17699 panic!(concat!(
17700 "Unable to load ",
17701 stringify!(create_acceleration_structure_nv)
17702 ))
17703 }
17704 let cname = CStr::from_bytes_with_nul_unchecked(
17705 b"vkCreateAccelerationStructureNV\0",
17706 );
17707 let val = _f(cname);
17708 if val.is_null() {
17709 create_acceleration_structure_nv
17710 } else {
17711 ::core::mem::transmute(val)
17712 }
17713 },
17714 destroy_acceleration_structure_nv: unsafe {
17715 unsafe extern "system" fn destroy_acceleration_structure_nv(
17716 _device: crate::vk::Device,
17717 _acceleration_structure: AccelerationStructureNV,
17718 _p_allocator: *const AllocationCallbacks<'_>,
17719 ) {
17720 panic!(concat!(
17721 "Unable to load ",
17722 stringify!(destroy_acceleration_structure_nv)
17723 ))
17724 }
17725 let cname = CStr::from_bytes_with_nul_unchecked(
17726 b"vkDestroyAccelerationStructureNV\0",
17727 );
17728 let val = _f(cname);
17729 if val.is_null() {
17730 destroy_acceleration_structure_nv
17731 } else {
17732 ::core::mem::transmute(val)
17733 }
17734 },
17735 get_acceleration_structure_memory_requirements_nv: unsafe {
17736 unsafe extern "system" fn get_acceleration_structure_memory_requirements_nv(
17737 _device: crate::vk::Device,
17738 _p_info: *const AccelerationStructureMemoryRequirementsInfoNV<'_>,
17739 _p_memory_requirements: *mut MemoryRequirements2KHR<'_>,
17740 ) {
17741 panic!(concat!(
17742 "Unable to load ",
17743 stringify!(get_acceleration_structure_memory_requirements_nv)
17744 ))
17745 }
17746 let cname = CStr::from_bytes_with_nul_unchecked(
17747 b"vkGetAccelerationStructureMemoryRequirementsNV\0",
17748 );
17749 let val = _f(cname);
17750 if val.is_null() {
17751 get_acceleration_structure_memory_requirements_nv
17752 } else {
17753 ::core::mem::transmute(val)
17754 }
17755 },
17756 bind_acceleration_structure_memory_nv: unsafe {
17757 unsafe extern "system" fn bind_acceleration_structure_memory_nv(
17758 _device: crate::vk::Device,
17759 _bind_info_count: u32,
17760 _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV<'_>,
17761 ) -> Result {
17762 panic!(concat!(
17763 "Unable to load ",
17764 stringify!(bind_acceleration_structure_memory_nv)
17765 ))
17766 }
17767 let cname = CStr::from_bytes_with_nul_unchecked(
17768 b"vkBindAccelerationStructureMemoryNV\0",
17769 );
17770 let val = _f(cname);
17771 if val.is_null() {
17772 bind_acceleration_structure_memory_nv
17773 } else {
17774 ::core::mem::transmute(val)
17775 }
17776 },
17777 cmd_build_acceleration_structure_nv: unsafe {
17778 unsafe extern "system" fn cmd_build_acceleration_structure_nv(
17779 _command_buffer: CommandBuffer,
17780 _p_info: *const AccelerationStructureInfoNV<'_>,
17781 _instance_data: Buffer,
17782 _instance_offset: DeviceSize,
17783 _update: Bool32,
17784 _dst: AccelerationStructureNV,
17785 _src: AccelerationStructureNV,
17786 _scratch: Buffer,
17787 _scratch_offset: DeviceSize,
17788 ) {
17789 panic!(concat!(
17790 "Unable to load ",
17791 stringify!(cmd_build_acceleration_structure_nv)
17792 ))
17793 }
17794 let cname = CStr::from_bytes_with_nul_unchecked(
17795 b"vkCmdBuildAccelerationStructureNV\0",
17796 );
17797 let val = _f(cname);
17798 if val.is_null() {
17799 cmd_build_acceleration_structure_nv
17800 } else {
17801 ::core::mem::transmute(val)
17802 }
17803 },
17804 cmd_copy_acceleration_structure_nv: unsafe {
17805 unsafe extern "system" fn cmd_copy_acceleration_structure_nv(
17806 _command_buffer: CommandBuffer,
17807 _dst: AccelerationStructureNV,
17808 _src: AccelerationStructureNV,
17809 _mode: CopyAccelerationStructureModeKHR,
17810 ) {
17811 panic!(concat!(
17812 "Unable to load ",
17813 stringify!(cmd_copy_acceleration_structure_nv)
17814 ))
17815 }
17816 let cname = CStr::from_bytes_with_nul_unchecked(
17817 b"vkCmdCopyAccelerationStructureNV\0",
17818 );
17819 let val = _f(cname);
17820 if val.is_null() {
17821 cmd_copy_acceleration_structure_nv
17822 } else {
17823 ::core::mem::transmute(val)
17824 }
17825 },
17826 cmd_trace_rays_nv: unsafe {
17827 unsafe extern "system" fn cmd_trace_rays_nv(
17828 _command_buffer: CommandBuffer,
17829 _raygen_shader_binding_table_buffer: Buffer,
17830 _raygen_shader_binding_offset: DeviceSize,
17831 _miss_shader_binding_table_buffer: Buffer,
17832 _miss_shader_binding_offset: DeviceSize,
17833 _miss_shader_binding_stride: DeviceSize,
17834 _hit_shader_binding_table_buffer: Buffer,
17835 _hit_shader_binding_offset: DeviceSize,
17836 _hit_shader_binding_stride: DeviceSize,
17837 _callable_shader_binding_table_buffer: Buffer,
17838 _callable_shader_binding_offset: DeviceSize,
17839 _callable_shader_binding_stride: DeviceSize,
17840 _width: u32,
17841 _height: u32,
17842 _depth: u32,
17843 ) {
17844 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv)))
17845 }
17846 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysNV\0");
17847 let val = _f(cname);
17848 if val.is_null() {
17849 cmd_trace_rays_nv
17850 } else {
17851 ::core::mem::transmute(val)
17852 }
17853 },
17854 create_ray_tracing_pipelines_nv: unsafe {
17855 unsafe extern "system" fn create_ray_tracing_pipelines_nv(
17856 _device: crate::vk::Device,
17857 _pipeline_cache: PipelineCache,
17858 _create_info_count: u32,
17859 _p_create_infos: *const RayTracingPipelineCreateInfoNV<'_>,
17860 _p_allocator: *const AllocationCallbacks<'_>,
17861 _p_pipelines: *mut Pipeline,
17862 ) -> Result {
17863 panic!(concat!(
17864 "Unable to load ",
17865 stringify!(create_ray_tracing_pipelines_nv)
17866 ))
17867 }
17868 let cname =
17869 CStr::from_bytes_with_nul_unchecked(b"vkCreateRayTracingPipelinesNV\0");
17870 let val = _f(cname);
17871 if val.is_null() {
17872 create_ray_tracing_pipelines_nv
17873 } else {
17874 ::core::mem::transmute(val)
17875 }
17876 },
17877 get_ray_tracing_shader_group_handles_nv: unsafe {
17878 unsafe extern "system" fn get_ray_tracing_shader_group_handles_nv(
17879 _device: crate::vk::Device,
17880 _pipeline: Pipeline,
17881 _first_group: u32,
17882 _group_count: u32,
17883 _data_size: usize,
17884 _p_data: *mut c_void,
17885 ) -> Result {
17886 panic!(concat!(
17887 "Unable to load ",
17888 stringify!(get_ray_tracing_shader_group_handles_nv)
17889 ))
17890 }
17891 let cname = CStr::from_bytes_with_nul_unchecked(
17892 b"vkGetRayTracingShaderGroupHandlesNV\0",
17893 );
17894 let val = _f(cname);
17895 if val.is_null() {
17896 get_ray_tracing_shader_group_handles_nv
17897 } else {
17898 ::core::mem::transmute(val)
17899 }
17900 },
17901 get_acceleration_structure_handle_nv: unsafe {
17902 unsafe extern "system" fn get_acceleration_structure_handle_nv(
17903 _device: crate::vk::Device,
17904 _acceleration_structure: AccelerationStructureNV,
17905 _data_size: usize,
17906 _p_data: *mut c_void,
17907 ) -> Result {
17908 panic!(concat!(
17909 "Unable to load ",
17910 stringify!(get_acceleration_structure_handle_nv)
17911 ))
17912 }
17913 let cname = CStr::from_bytes_with_nul_unchecked(
17914 b"vkGetAccelerationStructureHandleNV\0",
17915 );
17916 let val = _f(cname);
17917 if val.is_null() {
17918 get_acceleration_structure_handle_nv
17919 } else {
17920 ::core::mem::transmute(val)
17921 }
17922 },
17923 cmd_write_acceleration_structures_properties_nv: unsafe {
17924 unsafe extern "system" fn cmd_write_acceleration_structures_properties_nv(
17925 _command_buffer: CommandBuffer,
17926 _acceleration_structure_count: u32,
17927 _p_acceleration_structures: *const AccelerationStructureNV,
17928 _query_type: QueryType,
17929 _query_pool: QueryPool,
17930 _first_query: u32,
17931 ) {
17932 panic!(concat!(
17933 "Unable to load ",
17934 stringify!(cmd_write_acceleration_structures_properties_nv)
17935 ))
17936 }
17937 let cname = CStr::from_bytes_with_nul_unchecked(
17938 b"vkCmdWriteAccelerationStructuresPropertiesNV\0",
17939 );
17940 let val = _f(cname);
17941 if val.is_null() {
17942 cmd_write_acceleration_structures_properties_nv
17943 } else {
17944 ::core::mem::transmute(val)
17945 }
17946 },
17947 compile_deferred_nv: unsafe {
17948 unsafe extern "system" fn compile_deferred_nv(
17949 _device: crate::vk::Device,
17950 _pipeline: Pipeline,
17951 _shader: u32,
17952 ) -> Result {
17953 panic!(concat!("Unable to load ", stringify!(compile_deferred_nv)))
17954 }
17955 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCompileDeferredNV\0");
17956 let val = _f(cname);
17957 if val.is_null() {
17958 compile_deferred_nv
17959 } else {
17960 ::core::mem::transmute(val)
17961 }
17962 },
17963 }
17964 }
17965 }
17966 }
17967 #[doc = "VK_NV_representative_fragment_test"]
17968 pub mod representative_fragment_test {
17969 use super::super::*;
17970 pub use {
17971 crate::vk::NV_REPRESENTATIVE_FRAGMENT_TEST_NAME as NAME,
17972 crate::vk::NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION as SPEC_VERSION,
17973 };
17974 }
17975 #[doc = "VK_NV_shader_subgroup_partitioned"]
17976 pub mod shader_subgroup_partitioned {
17977 use super::super::*;
17978 pub use {
17979 crate::vk::NV_SHADER_SUBGROUP_PARTITIONED_NAME as NAME,
17980 crate::vk::NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION as SPEC_VERSION,
17981 };
17982 }
17983 #[doc = "VK_NV_compute_shader_derivatives"]
17984 pub mod compute_shader_derivatives {
17985 use super::super::*;
17986 pub use {
17987 crate::vk::NV_COMPUTE_SHADER_DERIVATIVES_NAME as NAME,
17988 crate::vk::NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION as SPEC_VERSION,
17989 };
17990 }
17991 #[doc = "VK_NV_mesh_shader"]
17992 pub mod mesh_shader {
17993 use super::super::*;
17994 pub use {
17995 crate::vk::NV_MESH_SHADER_NAME as NAME,
17996 crate::vk::NV_MESH_SHADER_SPEC_VERSION as SPEC_VERSION,
17997 };
17998 #[doc = "VK_NV_mesh_shader device-level functions"]
17999 #[derive(Clone)]
18000 pub struct Device {
18001 pub(crate) fp: DeviceFn,
18002 pub(crate) handle: crate::vk::Device,
18003 }
18004 impl Device {
18005 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18006 let handle = device.handle();
18007 let fp = DeviceFn::load(|name| unsafe {
18008 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18009 });
18010 Self { handle, fp }
18011 }
18012 #[inline]
18013 pub fn fp(&self) -> &DeviceFn {
18014 &self.fp
18015 }
18016 #[inline]
18017 pub fn device(&self) -> crate::vk::Device {
18018 self.handle
18019 }
18020 }
18021 #[derive(Clone)]
18022 #[doc = "Raw VK_NV_mesh_shader device-level function pointers"]
18023 pub struct DeviceFn {
18024 pub cmd_draw_mesh_tasks_nv: PFN_vkCmdDrawMeshTasksNV,
18025 pub cmd_draw_mesh_tasks_indirect_nv: PFN_vkCmdDrawMeshTasksIndirectNV,
18026 pub cmd_draw_mesh_tasks_indirect_count_nv: PFN_vkCmdDrawMeshTasksIndirectCountNV,
18027 }
18028 unsafe impl Send for DeviceFn {}
18029 unsafe impl Sync for DeviceFn {}
18030 impl DeviceFn {
18031 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18032 Self::load_erased(&mut f)
18033 }
18034 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18035 Self {
18036 cmd_draw_mesh_tasks_nv: unsafe {
18037 unsafe extern "system" fn cmd_draw_mesh_tasks_nv(
18038 _command_buffer: CommandBuffer,
18039 _task_count: u32,
18040 _first_task: u32,
18041 ) {
18042 panic!(concat!(
18043 "Unable to load ",
18044 stringify!(cmd_draw_mesh_tasks_nv)
18045 ))
18046 }
18047 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksNV\0");
18048 let val = _f(cname);
18049 if val.is_null() {
18050 cmd_draw_mesh_tasks_nv
18051 } else {
18052 ::core::mem::transmute(val)
18053 }
18054 },
18055 cmd_draw_mesh_tasks_indirect_nv: unsafe {
18056 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_nv(
18057 _command_buffer: CommandBuffer,
18058 _buffer: Buffer,
18059 _offset: DeviceSize,
18060 _draw_count: u32,
18061 _stride: u32,
18062 ) {
18063 panic!(concat!(
18064 "Unable to load ",
18065 stringify!(cmd_draw_mesh_tasks_indirect_nv)
18066 ))
18067 }
18068 let cname =
18069 CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksIndirectNV\0");
18070 let val = _f(cname);
18071 if val.is_null() {
18072 cmd_draw_mesh_tasks_indirect_nv
18073 } else {
18074 ::core::mem::transmute(val)
18075 }
18076 },
18077 cmd_draw_mesh_tasks_indirect_count_nv: unsafe {
18078 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv(
18079 _command_buffer: CommandBuffer,
18080 _buffer: Buffer,
18081 _offset: DeviceSize,
18082 _count_buffer: Buffer,
18083 _count_buffer_offset: DeviceSize,
18084 _max_draw_count: u32,
18085 _stride: u32,
18086 ) {
18087 panic!(concat!(
18088 "Unable to load ",
18089 stringify!(cmd_draw_mesh_tasks_indirect_count_nv)
18090 ))
18091 }
18092 let cname = CStr::from_bytes_with_nul_unchecked(
18093 b"vkCmdDrawMeshTasksIndirectCountNV\0",
18094 );
18095 let val = _f(cname);
18096 if val.is_null() {
18097 cmd_draw_mesh_tasks_indirect_count_nv
18098 } else {
18099 ::core::mem::transmute(val)
18100 }
18101 },
18102 }
18103 }
18104 }
18105 }
18106 #[doc = "VK_NV_fragment_shader_barycentric"]
18107 pub mod fragment_shader_barycentric {
18108 use super::super::*;
18109 pub use {
18110 crate::vk::NV_FRAGMENT_SHADER_BARYCENTRIC_NAME as NAME,
18111 crate::vk::NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION as SPEC_VERSION,
18112 };
18113 }
18114 #[doc = "VK_NV_shader_image_footprint"]
18115 pub mod shader_image_footprint {
18116 use super::super::*;
18117 pub use {
18118 crate::vk::NV_SHADER_IMAGE_FOOTPRINT_NAME as NAME,
18119 crate::vk::NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION as SPEC_VERSION,
18120 };
18121 }
18122 #[doc = "VK_NV_scissor_exclusive"]
18123 pub mod scissor_exclusive {
18124 use super::super::*;
18125 pub use {
18126 crate::vk::NV_SCISSOR_EXCLUSIVE_NAME as NAME,
18127 crate::vk::NV_SCISSOR_EXCLUSIVE_SPEC_VERSION as SPEC_VERSION,
18128 };
18129 #[doc = "VK_NV_scissor_exclusive device-level functions"]
18130 #[derive(Clone)]
18131 pub struct Device {
18132 pub(crate) fp: DeviceFn,
18133 pub(crate) handle: crate::vk::Device,
18134 }
18135 impl Device {
18136 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18137 let handle = device.handle();
18138 let fp = DeviceFn::load(|name| unsafe {
18139 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18140 });
18141 Self { handle, fp }
18142 }
18143 #[inline]
18144 pub fn fp(&self) -> &DeviceFn {
18145 &self.fp
18146 }
18147 #[inline]
18148 pub fn device(&self) -> crate::vk::Device {
18149 self.handle
18150 }
18151 }
18152 #[derive(Clone)]
18153 #[doc = "Raw VK_NV_scissor_exclusive device-level function pointers"]
18154 pub struct DeviceFn {
18155 pub cmd_set_exclusive_scissor_enable_nv: PFN_vkCmdSetExclusiveScissorEnableNV,
18156 pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV,
18157 }
18158 unsafe impl Send for DeviceFn {}
18159 unsafe impl Sync for DeviceFn {}
18160 impl DeviceFn {
18161 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18162 Self::load_erased(&mut f)
18163 }
18164 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18165 Self {
18166 cmd_set_exclusive_scissor_enable_nv: unsafe {
18167 unsafe extern "system" fn cmd_set_exclusive_scissor_enable_nv(
18168 _command_buffer: CommandBuffer,
18169 _first_exclusive_scissor: u32,
18170 _exclusive_scissor_count: u32,
18171 _p_exclusive_scissor_enables: *const Bool32,
18172 ) {
18173 panic!(concat!(
18174 "Unable to load ",
18175 stringify!(cmd_set_exclusive_scissor_enable_nv)
18176 ))
18177 }
18178 let cname = CStr::from_bytes_with_nul_unchecked(
18179 b"vkCmdSetExclusiveScissorEnableNV\0",
18180 );
18181 let val = _f(cname);
18182 if val.is_null() {
18183 cmd_set_exclusive_scissor_enable_nv
18184 } else {
18185 ::core::mem::transmute(val)
18186 }
18187 },
18188 cmd_set_exclusive_scissor_nv: unsafe {
18189 unsafe extern "system" fn cmd_set_exclusive_scissor_nv(
18190 _command_buffer: CommandBuffer,
18191 _first_exclusive_scissor: u32,
18192 _exclusive_scissor_count: u32,
18193 _p_exclusive_scissors: *const Rect2D,
18194 ) {
18195 panic!(concat!(
18196 "Unable to load ",
18197 stringify!(cmd_set_exclusive_scissor_nv)
18198 ))
18199 }
18200 let cname =
18201 CStr::from_bytes_with_nul_unchecked(b"vkCmdSetExclusiveScissorNV\0");
18202 let val = _f(cname);
18203 if val.is_null() {
18204 cmd_set_exclusive_scissor_nv
18205 } else {
18206 ::core::mem::transmute(val)
18207 }
18208 },
18209 }
18210 }
18211 }
18212 }
18213 #[doc = "VK_NV_device_diagnostic_checkpoints"]
18214 pub mod device_diagnostic_checkpoints {
18215 use super::super::*;
18216 pub use {
18217 crate::vk::NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_NAME as NAME,
18218 crate::vk::NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION as SPEC_VERSION,
18219 };
18220 #[doc = "VK_NV_device_diagnostic_checkpoints device-level functions"]
18221 #[derive(Clone)]
18222 pub struct Device {
18223 pub(crate) fp: DeviceFn,
18224 pub(crate) handle: crate::vk::Device,
18225 }
18226 impl Device {
18227 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18228 let handle = device.handle();
18229 let fp = DeviceFn::load(|name| unsafe {
18230 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18231 });
18232 Self { handle, fp }
18233 }
18234 #[inline]
18235 pub fn fp(&self) -> &DeviceFn {
18236 &self.fp
18237 }
18238 #[inline]
18239 pub fn device(&self) -> crate::vk::Device {
18240 self.handle
18241 }
18242 }
18243 #[derive(Clone)]
18244 #[doc = "Raw VK_NV_device_diagnostic_checkpoints device-level function pointers"]
18245 pub struct DeviceFn {
18246 pub cmd_set_checkpoint_nv: PFN_vkCmdSetCheckpointNV,
18247 pub get_queue_checkpoint_data_nv: PFN_vkGetQueueCheckpointDataNV,
18248 }
18249 unsafe impl Send for DeviceFn {}
18250 unsafe impl Sync for DeviceFn {}
18251 impl DeviceFn {
18252 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18253 Self::load_erased(&mut f)
18254 }
18255 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18256 Self {
18257 cmd_set_checkpoint_nv: unsafe {
18258 unsafe extern "system" fn cmd_set_checkpoint_nv(
18259 _command_buffer: CommandBuffer,
18260 _p_checkpoint_marker: *const c_void,
18261 ) {
18262 panic!(concat!(
18263 "Unable to load ",
18264 stringify!(cmd_set_checkpoint_nv)
18265 ))
18266 }
18267 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCheckpointNV\0");
18268 let val = _f(cname);
18269 if val.is_null() {
18270 cmd_set_checkpoint_nv
18271 } else {
18272 ::core::mem::transmute(val)
18273 }
18274 },
18275 get_queue_checkpoint_data_nv: unsafe {
18276 unsafe extern "system" fn get_queue_checkpoint_data_nv(
18277 _queue: Queue,
18278 _p_checkpoint_data_count: *mut u32,
18279 _p_checkpoint_data: *mut CheckpointDataNV<'_>,
18280 ) {
18281 panic!(concat!(
18282 "Unable to load ",
18283 stringify!(get_queue_checkpoint_data_nv)
18284 ))
18285 }
18286 let cname =
18287 CStr::from_bytes_with_nul_unchecked(b"vkGetQueueCheckpointDataNV\0");
18288 let val = _f(cname);
18289 if val.is_null() {
18290 get_queue_checkpoint_data_nv
18291 } else {
18292 ::core::mem::transmute(val)
18293 }
18294 },
18295 }
18296 }
18297 }
18298 }
18299 #[doc = "VK_NV_dedicated_allocation_image_aliasing"]
18300 pub mod dedicated_allocation_image_aliasing {
18301 use super::super::*;
18302 pub use {
18303 crate::vk::NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_NAME as NAME,
18304 crate::vk::NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION as SPEC_VERSION,
18305 };
18306 }
18307 #[doc = "VK_NV_cooperative_matrix"]
18308 pub mod cooperative_matrix {
18309 use super::super::*;
18310 pub use {
18311 crate::vk::NV_COOPERATIVE_MATRIX_NAME as NAME,
18312 crate::vk::NV_COOPERATIVE_MATRIX_SPEC_VERSION as SPEC_VERSION,
18313 };
18314 #[doc = "VK_NV_cooperative_matrix instance-level functions"]
18315 #[derive(Clone)]
18316 pub struct Instance {
18317 pub(crate) fp: InstanceFn,
18318 pub(crate) handle: crate::vk::Instance,
18319 }
18320 impl Instance {
18321 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
18322 let handle = instance.handle();
18323 let fp = InstanceFn::load(|name| unsafe {
18324 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
18325 });
18326 Self { handle, fp }
18327 }
18328 #[inline]
18329 pub fn fp(&self) -> &InstanceFn {
18330 &self.fp
18331 }
18332 #[inline]
18333 pub fn instance(&self) -> crate::vk::Instance {
18334 self.handle
18335 }
18336 }
18337 #[derive(Clone)]
18338 #[doc = "Raw VK_NV_cooperative_matrix instance-level function pointers"]
18339 pub struct InstanceFn {
18340 pub get_physical_device_cooperative_matrix_properties_nv:
18341 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
18342 }
18343 unsafe impl Send for InstanceFn {}
18344 unsafe impl Sync for InstanceFn {}
18345 impl InstanceFn {
18346 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18347 Self::load_erased(&mut f)
18348 }
18349 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18350 Self {
18351 get_physical_device_cooperative_matrix_properties_nv: unsafe {
18352 unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv(
18353 _physical_device: PhysicalDevice,
18354 _p_property_count: *mut u32,
18355 _p_properties: *mut CooperativeMatrixPropertiesNV<'_>,
18356 ) -> Result {
18357 panic!(concat!(
18358 "Unable to load ",
18359 stringify!(get_physical_device_cooperative_matrix_properties_nv)
18360 ))
18361 }
18362 let cname = CStr::from_bytes_with_nul_unchecked(
18363 b"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\0",
18364 );
18365 let val = _f(cname);
18366 if val.is_null() {
18367 get_physical_device_cooperative_matrix_properties_nv
18368 } else {
18369 ::core::mem::transmute(val)
18370 }
18371 },
18372 }
18373 }
18374 }
18375 }
18376 #[doc = "VK_NV_coverage_reduction_mode"]
18377 pub mod coverage_reduction_mode {
18378 use super::super::*;
18379 pub use {
18380 crate::vk::NV_COVERAGE_REDUCTION_MODE_NAME as NAME,
18381 crate::vk::NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION as SPEC_VERSION,
18382 };
18383 #[doc = "VK_NV_coverage_reduction_mode instance-level functions"]
18384 #[derive(Clone)]
18385 pub struct Instance {
18386 pub(crate) fp: InstanceFn,
18387 pub(crate) handle: crate::vk::Instance,
18388 }
18389 impl Instance {
18390 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
18391 let handle = instance.handle();
18392 let fp = InstanceFn::load(|name| unsafe {
18393 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
18394 });
18395 Self { handle, fp }
18396 }
18397 #[inline]
18398 pub fn fp(&self) -> &InstanceFn {
18399 &self.fp
18400 }
18401 #[inline]
18402 pub fn instance(&self) -> crate::vk::Instance {
18403 self.handle
18404 }
18405 }
18406 #[derive(Clone)]
18407 #[doc = "Raw VK_NV_coverage_reduction_mode instance-level function pointers"]
18408 pub struct InstanceFn {
18409 pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv:
18410 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
18411 }
18412 unsafe impl Send for InstanceFn {}
18413 unsafe impl Sync for InstanceFn {}
18414 impl InstanceFn {
18415 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18416 Self::load_erased(&mut f)
18417 }
18418 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18419 Self {
18420 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe {
18421 unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
18422 _physical_device: PhysicalDevice,
18423 _p_combination_count: *mut u32,
18424 _p_combinations: *mut FramebufferMixedSamplesCombinationNV<'_>,
18425 ) -> Result {
18426 panic ! (concat ! ("Unable to load " , stringify ! (get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)))
18427 }
18428 let cname = CStr::from_bytes_with_nul_unchecked(
18429 b"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\0",
18430 );
18431 let val = _f(cname);
18432 if val.is_null() {
18433 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
18434 } else {
18435 ::core::mem::transmute(val)
18436 }
18437 },
18438 }
18439 }
18440 }
18441 }
18442 #[doc = "VK_NV_device_generated_commands"]
18443 pub mod device_generated_commands {
18444 use super::super::*;
18445 pub use {
18446 crate::vk::NV_DEVICE_GENERATED_COMMANDS_NAME as NAME,
18447 crate::vk::NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION as SPEC_VERSION,
18448 };
18449 #[doc = "VK_NV_device_generated_commands device-level functions"]
18450 #[derive(Clone)]
18451 pub struct Device {
18452 pub(crate) fp: DeviceFn,
18453 pub(crate) handle: crate::vk::Device,
18454 }
18455 impl Device {
18456 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18457 let handle = device.handle();
18458 let fp = DeviceFn::load(|name| unsafe {
18459 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18460 });
18461 Self { handle, fp }
18462 }
18463 #[inline]
18464 pub fn fp(&self) -> &DeviceFn {
18465 &self.fp
18466 }
18467 #[inline]
18468 pub fn device(&self) -> crate::vk::Device {
18469 self.handle
18470 }
18471 }
18472 #[derive(Clone)]
18473 #[doc = "Raw VK_NV_device_generated_commands device-level function pointers"]
18474 pub struct DeviceFn {
18475 pub get_generated_commands_memory_requirements_nv:
18476 PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
18477 pub cmd_preprocess_generated_commands_nv: PFN_vkCmdPreprocessGeneratedCommandsNV,
18478 pub cmd_execute_generated_commands_nv: PFN_vkCmdExecuteGeneratedCommandsNV,
18479 pub cmd_bind_pipeline_shader_group_nv: PFN_vkCmdBindPipelineShaderGroupNV,
18480 pub create_indirect_commands_layout_nv: PFN_vkCreateIndirectCommandsLayoutNV,
18481 pub destroy_indirect_commands_layout_nv: PFN_vkDestroyIndirectCommandsLayoutNV,
18482 }
18483 unsafe impl Send for DeviceFn {}
18484 unsafe impl Sync for DeviceFn {}
18485 impl DeviceFn {
18486 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18487 Self::load_erased(&mut f)
18488 }
18489 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18490 Self {
18491 get_generated_commands_memory_requirements_nv: unsafe {
18492 unsafe extern "system" fn get_generated_commands_memory_requirements_nv(
18493 _device: crate::vk::Device,
18494 _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV<'_>,
18495 _p_memory_requirements: *mut MemoryRequirements2<'_>,
18496 ) {
18497 panic!(concat!(
18498 "Unable to load ",
18499 stringify!(get_generated_commands_memory_requirements_nv)
18500 ))
18501 }
18502 let cname = CStr::from_bytes_with_nul_unchecked(
18503 b"vkGetGeneratedCommandsMemoryRequirementsNV\0",
18504 );
18505 let val = _f(cname);
18506 if val.is_null() {
18507 get_generated_commands_memory_requirements_nv
18508 } else {
18509 ::core::mem::transmute(val)
18510 }
18511 },
18512 cmd_preprocess_generated_commands_nv: unsafe {
18513 unsafe extern "system" fn cmd_preprocess_generated_commands_nv(
18514 _command_buffer: CommandBuffer,
18515 _p_generated_commands_info: *const GeneratedCommandsInfoNV<'_>,
18516 ) {
18517 panic!(concat!(
18518 "Unable to load ",
18519 stringify!(cmd_preprocess_generated_commands_nv)
18520 ))
18521 }
18522 let cname = CStr::from_bytes_with_nul_unchecked(
18523 b"vkCmdPreprocessGeneratedCommandsNV\0",
18524 );
18525 let val = _f(cname);
18526 if val.is_null() {
18527 cmd_preprocess_generated_commands_nv
18528 } else {
18529 ::core::mem::transmute(val)
18530 }
18531 },
18532 cmd_execute_generated_commands_nv: unsafe {
18533 unsafe extern "system" fn cmd_execute_generated_commands_nv(
18534 _command_buffer: CommandBuffer,
18535 _is_preprocessed: Bool32,
18536 _p_generated_commands_info: *const GeneratedCommandsInfoNV<'_>,
18537 ) {
18538 panic!(concat!(
18539 "Unable to load ",
18540 stringify!(cmd_execute_generated_commands_nv)
18541 ))
18542 }
18543 let cname = CStr::from_bytes_with_nul_unchecked(
18544 b"vkCmdExecuteGeneratedCommandsNV\0",
18545 );
18546 let val = _f(cname);
18547 if val.is_null() {
18548 cmd_execute_generated_commands_nv
18549 } else {
18550 ::core::mem::transmute(val)
18551 }
18552 },
18553 cmd_bind_pipeline_shader_group_nv: unsafe {
18554 unsafe extern "system" fn cmd_bind_pipeline_shader_group_nv(
18555 _command_buffer: CommandBuffer,
18556 _pipeline_bind_point: PipelineBindPoint,
18557 _pipeline: Pipeline,
18558 _group_index: u32,
18559 ) {
18560 panic!(concat!(
18561 "Unable to load ",
18562 stringify!(cmd_bind_pipeline_shader_group_nv)
18563 ))
18564 }
18565 let cname = CStr::from_bytes_with_nul_unchecked(
18566 b"vkCmdBindPipelineShaderGroupNV\0",
18567 );
18568 let val = _f(cname);
18569 if val.is_null() {
18570 cmd_bind_pipeline_shader_group_nv
18571 } else {
18572 ::core::mem::transmute(val)
18573 }
18574 },
18575 create_indirect_commands_layout_nv: unsafe {
18576 unsafe extern "system" fn create_indirect_commands_layout_nv(
18577 _device: crate::vk::Device,
18578 _p_create_info: *const IndirectCommandsLayoutCreateInfoNV<'_>,
18579 _p_allocator: *const AllocationCallbacks<'_>,
18580 _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
18581 ) -> Result {
18582 panic!(concat!(
18583 "Unable to load ",
18584 stringify!(create_indirect_commands_layout_nv)
18585 ))
18586 }
18587 let cname = CStr::from_bytes_with_nul_unchecked(
18588 b"vkCreateIndirectCommandsLayoutNV\0",
18589 );
18590 let val = _f(cname);
18591 if val.is_null() {
18592 create_indirect_commands_layout_nv
18593 } else {
18594 ::core::mem::transmute(val)
18595 }
18596 },
18597 destroy_indirect_commands_layout_nv: unsafe {
18598 unsafe extern "system" fn destroy_indirect_commands_layout_nv(
18599 _device: crate::vk::Device,
18600 _indirect_commands_layout: IndirectCommandsLayoutNV,
18601 _p_allocator: *const AllocationCallbacks<'_>,
18602 ) {
18603 panic!(concat!(
18604 "Unable to load ",
18605 stringify!(destroy_indirect_commands_layout_nv)
18606 ))
18607 }
18608 let cname = CStr::from_bytes_with_nul_unchecked(
18609 b"vkDestroyIndirectCommandsLayoutNV\0",
18610 );
18611 let val = _f(cname);
18612 if val.is_null() {
18613 destroy_indirect_commands_layout_nv
18614 } else {
18615 ::core::mem::transmute(val)
18616 }
18617 },
18618 }
18619 }
18620 }
18621 }
18622 #[doc = "VK_NV_inherited_viewport_scissor"]
18623 pub mod inherited_viewport_scissor {
18624 use super::super::*;
18625 pub use {
18626 crate::vk::NV_INHERITED_VIEWPORT_SCISSOR_NAME as NAME,
18627 crate::vk::NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION as SPEC_VERSION,
18628 };
18629 }
18630 #[doc = "VK_NV_present_barrier"]
18631 pub mod present_barrier {
18632 use super::super::*;
18633 pub use {
18634 crate::vk::NV_PRESENT_BARRIER_NAME as NAME,
18635 crate::vk::NV_PRESENT_BARRIER_SPEC_VERSION as SPEC_VERSION,
18636 };
18637 }
18638 #[doc = "VK_NV_device_diagnostics_config"]
18639 pub mod device_diagnostics_config {
18640 use super::super::*;
18641 pub use {
18642 crate::vk::NV_DEVICE_DIAGNOSTICS_CONFIG_NAME as NAME,
18643 crate::vk::NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION as SPEC_VERSION,
18644 };
18645 }
18646 #[doc = "VK_NV_cuda_kernel_launch"]
18647 pub mod cuda_kernel_launch {
18648 use super::super::*;
18649 pub use {
18650 crate::vk::NV_CUDA_KERNEL_LAUNCH_NAME as NAME,
18651 crate::vk::NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION as SPEC_VERSION,
18652 };
18653 #[doc = "VK_NV_cuda_kernel_launch device-level functions"]
18654 #[derive(Clone)]
18655 pub struct Device {
18656 pub(crate) fp: DeviceFn,
18657 pub(crate) handle: crate::vk::Device,
18658 }
18659 impl Device {
18660 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18661 let handle = device.handle();
18662 let fp = DeviceFn::load(|name| unsafe {
18663 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18664 });
18665 Self { handle, fp }
18666 }
18667 #[inline]
18668 pub fn fp(&self) -> &DeviceFn {
18669 &self.fp
18670 }
18671 #[inline]
18672 pub fn device(&self) -> crate::vk::Device {
18673 self.handle
18674 }
18675 }
18676 #[derive(Clone)]
18677 #[doc = "Raw VK_NV_cuda_kernel_launch device-level function pointers"]
18678 pub struct DeviceFn {
18679 pub create_cuda_module_nv: PFN_vkCreateCudaModuleNV,
18680 pub get_cuda_module_cache_nv: PFN_vkGetCudaModuleCacheNV,
18681 pub create_cuda_function_nv: PFN_vkCreateCudaFunctionNV,
18682 pub destroy_cuda_module_nv: PFN_vkDestroyCudaModuleNV,
18683 pub destroy_cuda_function_nv: PFN_vkDestroyCudaFunctionNV,
18684 pub cmd_cuda_launch_kernel_nv: PFN_vkCmdCudaLaunchKernelNV,
18685 }
18686 unsafe impl Send for DeviceFn {}
18687 unsafe impl Sync for DeviceFn {}
18688 impl DeviceFn {
18689 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18690 Self::load_erased(&mut f)
18691 }
18692 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18693 Self {
18694 create_cuda_module_nv: unsafe {
18695 unsafe extern "system" fn create_cuda_module_nv(
18696 _device: crate::vk::Device,
18697 _p_create_info: *const CudaModuleCreateInfoNV<'_>,
18698 _p_allocator: *const AllocationCallbacks<'_>,
18699 _p_module: *mut CudaModuleNV,
18700 ) -> Result {
18701 panic!(concat!(
18702 "Unable to load ",
18703 stringify!(create_cuda_module_nv)
18704 ))
18705 }
18706 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateCudaModuleNV\0");
18707 let val = _f(cname);
18708 if val.is_null() {
18709 create_cuda_module_nv
18710 } else {
18711 ::core::mem::transmute(val)
18712 }
18713 },
18714 get_cuda_module_cache_nv: unsafe {
18715 unsafe extern "system" fn get_cuda_module_cache_nv(
18716 _device: crate::vk::Device,
18717 _module: CudaModuleNV,
18718 _p_cache_size: *mut usize,
18719 _p_cache_data: *mut c_void,
18720 ) -> Result {
18721 panic!(concat!(
18722 "Unable to load ",
18723 stringify!(get_cuda_module_cache_nv)
18724 ))
18725 }
18726 let cname =
18727 CStr::from_bytes_with_nul_unchecked(b"vkGetCudaModuleCacheNV\0");
18728 let val = _f(cname);
18729 if val.is_null() {
18730 get_cuda_module_cache_nv
18731 } else {
18732 ::core::mem::transmute(val)
18733 }
18734 },
18735 create_cuda_function_nv: unsafe {
18736 unsafe extern "system" fn create_cuda_function_nv(
18737 _device: crate::vk::Device,
18738 _p_create_info: *const CudaFunctionCreateInfoNV<'_>,
18739 _p_allocator: *const AllocationCallbacks<'_>,
18740 _p_function: *mut CudaFunctionNV,
18741 ) -> Result {
18742 panic!(concat!(
18743 "Unable to load ",
18744 stringify!(create_cuda_function_nv)
18745 ))
18746 }
18747 let cname =
18748 CStr::from_bytes_with_nul_unchecked(b"vkCreateCudaFunctionNV\0");
18749 let val = _f(cname);
18750 if val.is_null() {
18751 create_cuda_function_nv
18752 } else {
18753 ::core::mem::transmute(val)
18754 }
18755 },
18756 destroy_cuda_module_nv: unsafe {
18757 unsafe extern "system" fn destroy_cuda_module_nv(
18758 _device: crate::vk::Device,
18759 _module: CudaModuleNV,
18760 _p_allocator: *const AllocationCallbacks<'_>,
18761 ) {
18762 panic!(concat!(
18763 "Unable to load ",
18764 stringify!(destroy_cuda_module_nv)
18765 ))
18766 }
18767 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyCudaModuleNV\0");
18768 let val = _f(cname);
18769 if val.is_null() {
18770 destroy_cuda_module_nv
18771 } else {
18772 ::core::mem::transmute(val)
18773 }
18774 },
18775 destroy_cuda_function_nv: unsafe {
18776 unsafe extern "system" fn destroy_cuda_function_nv(
18777 _device: crate::vk::Device,
18778 _function: CudaFunctionNV,
18779 _p_allocator: *const AllocationCallbacks<'_>,
18780 ) {
18781 panic!(concat!(
18782 "Unable to load ",
18783 stringify!(destroy_cuda_function_nv)
18784 ))
18785 }
18786 let cname =
18787 CStr::from_bytes_with_nul_unchecked(b"vkDestroyCudaFunctionNV\0");
18788 let val = _f(cname);
18789 if val.is_null() {
18790 destroy_cuda_function_nv
18791 } else {
18792 ::core::mem::transmute(val)
18793 }
18794 },
18795 cmd_cuda_launch_kernel_nv: unsafe {
18796 unsafe extern "system" fn cmd_cuda_launch_kernel_nv(
18797 _command_buffer: CommandBuffer,
18798 _p_launch_info: *const CudaLaunchInfoNV<'_>,
18799 ) {
18800 panic!(concat!(
18801 "Unable to load ",
18802 stringify!(cmd_cuda_launch_kernel_nv)
18803 ))
18804 }
18805 let cname =
18806 CStr::from_bytes_with_nul_unchecked(b"vkCmdCudaLaunchKernelNV\0");
18807 let val = _f(cname);
18808 if val.is_null() {
18809 cmd_cuda_launch_kernel_nv
18810 } else {
18811 ::core::mem::transmute(val)
18812 }
18813 },
18814 }
18815 }
18816 }
18817 }
18818 #[doc = "VK_NV_low_latency"]
18819 pub mod low_latency {
18820 use super::super::*;
18821 pub use {
18822 crate::vk::NV_LOW_LATENCY_NAME as NAME,
18823 crate::vk::NV_LOW_LATENCY_SPEC_VERSION as SPEC_VERSION,
18824 };
18825 }
18826 #[doc = "VK_NV_fragment_shading_rate_enums"]
18827 pub mod fragment_shading_rate_enums {
18828 use super::super::*;
18829 pub use {
18830 crate::vk::NV_FRAGMENT_SHADING_RATE_ENUMS_NAME as NAME,
18831 crate::vk::NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION as SPEC_VERSION,
18832 };
18833 #[doc = "VK_NV_fragment_shading_rate_enums device-level functions"]
18834 #[derive(Clone)]
18835 pub struct Device {
18836 pub(crate) fp: DeviceFn,
18837 pub(crate) handle: crate::vk::Device,
18838 }
18839 impl Device {
18840 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
18841 let handle = device.handle();
18842 let fp = DeviceFn::load(|name| unsafe {
18843 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
18844 });
18845 Self { handle, fp }
18846 }
18847 #[inline]
18848 pub fn fp(&self) -> &DeviceFn {
18849 &self.fp
18850 }
18851 #[inline]
18852 pub fn device(&self) -> crate::vk::Device {
18853 self.handle
18854 }
18855 }
18856 #[derive(Clone)]
18857 #[doc = "Raw VK_NV_fragment_shading_rate_enums device-level function pointers"]
18858 pub struct DeviceFn {
18859 pub cmd_set_fragment_shading_rate_enum_nv: PFN_vkCmdSetFragmentShadingRateEnumNV,
18860 }
18861 unsafe impl Send for DeviceFn {}
18862 unsafe impl Sync for DeviceFn {}
18863 impl DeviceFn {
18864 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18865 Self::load_erased(&mut f)
18866 }
18867 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18868 Self {
18869 cmd_set_fragment_shading_rate_enum_nv: unsafe {
18870 unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv(
18871 _command_buffer: CommandBuffer,
18872 _shading_rate: FragmentShadingRateNV,
18873 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
18874 ) {
18875 panic!(concat!(
18876 "Unable to load ",
18877 stringify!(cmd_set_fragment_shading_rate_enum_nv)
18878 ))
18879 }
18880 let cname = CStr::from_bytes_with_nul_unchecked(
18881 b"vkCmdSetFragmentShadingRateEnumNV\0",
18882 );
18883 let val = _f(cname);
18884 if val.is_null() {
18885 cmd_set_fragment_shading_rate_enum_nv
18886 } else {
18887 ::core::mem::transmute(val)
18888 }
18889 },
18890 }
18891 }
18892 }
18893 }
18894 #[doc = "VK_NV_ray_tracing_motion_blur"]
18895 pub mod ray_tracing_motion_blur {
18896 use super::super::*;
18897 pub use {
18898 crate::vk::NV_RAY_TRACING_MOTION_BLUR_NAME as NAME,
18899 crate::vk::NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION as SPEC_VERSION,
18900 };
18901 }
18902 #[doc = "VK_NV_acquire_winrt_display"]
18903 pub mod acquire_winrt_display {
18904 use super::super::*;
18905 pub use {
18906 crate::vk::NV_ACQUIRE_WINRT_DISPLAY_NAME as NAME,
18907 crate::vk::NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION as SPEC_VERSION,
18908 };
18909 #[doc = "VK_NV_acquire_winrt_display instance-level functions"]
18910 #[derive(Clone)]
18911 pub struct Instance {
18912 pub(crate) fp: InstanceFn,
18913 pub(crate) handle: crate::vk::Instance,
18914 }
18915 impl Instance {
18916 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
18917 let handle = instance.handle();
18918 let fp = InstanceFn::load(|name| unsafe {
18919 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
18920 });
18921 Self { handle, fp }
18922 }
18923 #[inline]
18924 pub fn fp(&self) -> &InstanceFn {
18925 &self.fp
18926 }
18927 #[inline]
18928 pub fn instance(&self) -> crate::vk::Instance {
18929 self.handle
18930 }
18931 }
18932 #[derive(Clone)]
18933 #[doc = "Raw VK_NV_acquire_winrt_display instance-level function pointers"]
18934 pub struct InstanceFn {
18935 pub acquire_winrt_display_nv: PFN_vkAcquireWinrtDisplayNV,
18936 pub get_winrt_display_nv: PFN_vkGetWinrtDisplayNV,
18937 }
18938 unsafe impl Send for InstanceFn {}
18939 unsafe impl Sync for InstanceFn {}
18940 impl InstanceFn {
18941 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
18942 Self::load_erased(&mut f)
18943 }
18944 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
18945 Self {
18946 acquire_winrt_display_nv: unsafe {
18947 unsafe extern "system" fn acquire_winrt_display_nv(
18948 _physical_device: PhysicalDevice,
18949 _display: DisplayKHR,
18950 ) -> Result {
18951 panic!(concat!(
18952 "Unable to load ",
18953 stringify!(acquire_winrt_display_nv)
18954 ))
18955 }
18956 let cname =
18957 CStr::from_bytes_with_nul_unchecked(b"vkAcquireWinrtDisplayNV\0");
18958 let val = _f(cname);
18959 if val.is_null() {
18960 acquire_winrt_display_nv
18961 } else {
18962 ::core::mem::transmute(val)
18963 }
18964 },
18965 get_winrt_display_nv: unsafe {
18966 unsafe extern "system" fn get_winrt_display_nv(
18967 _physical_device: PhysicalDevice,
18968 _device_relative_id: u32,
18969 _p_display: *mut DisplayKHR,
18970 ) -> Result {
18971 panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv)))
18972 }
18973 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetWinrtDisplayNV\0");
18974 let val = _f(cname);
18975 if val.is_null() {
18976 get_winrt_display_nv
18977 } else {
18978 ::core::mem::transmute(val)
18979 }
18980 },
18981 }
18982 }
18983 }
18984 }
18985 #[doc = "VK_NV_external_memory_rdma"]
18986 pub mod external_memory_rdma {
18987 use super::super::*;
18988 pub use {
18989 crate::vk::NV_EXTERNAL_MEMORY_RDMA_NAME as NAME,
18990 crate::vk::NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION as SPEC_VERSION,
18991 };
18992 #[doc = "VK_NV_external_memory_rdma device-level functions"]
18993 #[derive(Clone)]
18994 pub struct Device {
18995 pub(crate) fp: DeviceFn,
18996 pub(crate) handle: crate::vk::Device,
18997 }
18998 impl Device {
18999 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19000 let handle = device.handle();
19001 let fp = DeviceFn::load(|name| unsafe {
19002 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19003 });
19004 Self { handle, fp }
19005 }
19006 #[inline]
19007 pub fn fp(&self) -> &DeviceFn {
19008 &self.fp
19009 }
19010 #[inline]
19011 pub fn device(&self) -> crate::vk::Device {
19012 self.handle
19013 }
19014 }
19015 #[derive(Clone)]
19016 #[doc = "Raw VK_NV_external_memory_rdma device-level function pointers"]
19017 pub struct DeviceFn {
19018 pub get_memory_remote_address_nv: PFN_vkGetMemoryRemoteAddressNV,
19019 }
19020 unsafe impl Send for DeviceFn {}
19021 unsafe impl Sync for DeviceFn {}
19022 impl DeviceFn {
19023 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19024 Self::load_erased(&mut f)
19025 }
19026 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19027 Self {
19028 get_memory_remote_address_nv: unsafe {
19029 unsafe extern "system" fn get_memory_remote_address_nv(
19030 _device: crate::vk::Device,
19031 _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV<
19032 '_,
19033 >,
19034 _p_address: *mut RemoteAddressNV,
19035 ) -> Result {
19036 panic!(concat!(
19037 "Unable to load ",
19038 stringify!(get_memory_remote_address_nv)
19039 ))
19040 }
19041 let cname =
19042 CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryRemoteAddressNV\0");
19043 let val = _f(cname);
19044 if val.is_null() {
19045 get_memory_remote_address_nv
19046 } else {
19047 ::core::mem::transmute(val)
19048 }
19049 },
19050 }
19051 }
19052 }
19053 }
19054 #[doc = "VK_NV_displacement_micromap"]
19055 pub mod displacement_micromap {
19056 use super::super::*;
19057 pub use {
19058 crate::vk::NV_DISPLACEMENT_MICROMAP_NAME as NAME,
19059 crate::vk::NV_DISPLACEMENT_MICROMAP_SPEC_VERSION as SPEC_VERSION,
19060 };
19061 }
19062 #[doc = "VK_NV_copy_memory_indirect"]
19063 pub mod copy_memory_indirect {
19064 use super::super::*;
19065 pub use {
19066 crate::vk::NV_COPY_MEMORY_INDIRECT_NAME as NAME,
19067 crate::vk::NV_COPY_MEMORY_INDIRECT_SPEC_VERSION as SPEC_VERSION,
19068 };
19069 #[doc = "VK_NV_copy_memory_indirect device-level functions"]
19070 #[derive(Clone)]
19071 pub struct Device {
19072 pub(crate) fp: DeviceFn,
19073 pub(crate) handle: crate::vk::Device,
19074 }
19075 impl Device {
19076 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19077 let handle = device.handle();
19078 let fp = DeviceFn::load(|name| unsafe {
19079 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19080 });
19081 Self { handle, fp }
19082 }
19083 #[inline]
19084 pub fn fp(&self) -> &DeviceFn {
19085 &self.fp
19086 }
19087 #[inline]
19088 pub fn device(&self) -> crate::vk::Device {
19089 self.handle
19090 }
19091 }
19092 #[derive(Clone)]
19093 #[doc = "Raw VK_NV_copy_memory_indirect device-level function pointers"]
19094 pub struct DeviceFn {
19095 pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV,
19096 pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV,
19097 }
19098 unsafe impl Send for DeviceFn {}
19099 unsafe impl Sync for DeviceFn {}
19100 impl DeviceFn {
19101 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19102 Self::load_erased(&mut f)
19103 }
19104 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19105 Self {
19106 cmd_copy_memory_indirect_nv: unsafe {
19107 unsafe extern "system" fn cmd_copy_memory_indirect_nv(
19108 _command_buffer: CommandBuffer,
19109 _copy_buffer_address: DeviceAddress,
19110 _copy_count: u32,
19111 _stride: u32,
19112 ) {
19113 panic!(concat!(
19114 "Unable to load ",
19115 stringify!(cmd_copy_memory_indirect_nv)
19116 ))
19117 }
19118 let cname =
19119 CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0");
19120 let val = _f(cname);
19121 if val.is_null() {
19122 cmd_copy_memory_indirect_nv
19123 } else {
19124 ::core::mem::transmute(val)
19125 }
19126 },
19127 cmd_copy_memory_to_image_indirect_nv: unsafe {
19128 unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv(
19129 _command_buffer: CommandBuffer,
19130 _copy_buffer_address: DeviceAddress,
19131 _copy_count: u32,
19132 _stride: u32,
19133 _dst_image: Image,
19134 _dst_image_layout: ImageLayout,
19135 _p_image_subresources: *const ImageSubresourceLayers,
19136 ) {
19137 panic!(concat!(
19138 "Unable to load ",
19139 stringify!(cmd_copy_memory_to_image_indirect_nv)
19140 ))
19141 }
19142 let cname = CStr::from_bytes_with_nul_unchecked(
19143 b"vkCmdCopyMemoryToImageIndirectNV\0",
19144 );
19145 let val = _f(cname);
19146 if val.is_null() {
19147 cmd_copy_memory_to_image_indirect_nv
19148 } else {
19149 ::core::mem::transmute(val)
19150 }
19151 },
19152 }
19153 }
19154 }
19155 }
19156 #[doc = "VK_NV_memory_decompression"]
19157 pub mod memory_decompression {
19158 use super::super::*;
19159 pub use {
19160 crate::vk::NV_MEMORY_DECOMPRESSION_NAME as NAME,
19161 crate::vk::NV_MEMORY_DECOMPRESSION_SPEC_VERSION as SPEC_VERSION,
19162 };
19163 #[doc = "VK_NV_memory_decompression device-level functions"]
19164 #[derive(Clone)]
19165 pub struct Device {
19166 pub(crate) fp: DeviceFn,
19167 pub(crate) handle: crate::vk::Device,
19168 }
19169 impl Device {
19170 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19171 let handle = device.handle();
19172 let fp = DeviceFn::load(|name| unsafe {
19173 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19174 });
19175 Self { handle, fp }
19176 }
19177 #[inline]
19178 pub fn fp(&self) -> &DeviceFn {
19179 &self.fp
19180 }
19181 #[inline]
19182 pub fn device(&self) -> crate::vk::Device {
19183 self.handle
19184 }
19185 }
19186 #[derive(Clone)]
19187 #[doc = "Raw VK_NV_memory_decompression device-level function pointers"]
19188 pub struct DeviceFn {
19189 pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV,
19190 pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV,
19191 }
19192 unsafe impl Send for DeviceFn {}
19193 unsafe impl Sync for DeviceFn {}
19194 impl DeviceFn {
19195 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19196 Self::load_erased(&mut f)
19197 }
19198 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19199 Self {
19200 cmd_decompress_memory_nv: unsafe {
19201 unsafe extern "system" fn cmd_decompress_memory_nv(
19202 _command_buffer: CommandBuffer,
19203 _decompress_region_count: u32,
19204 _p_decompress_memory_regions: *const DecompressMemoryRegionNV,
19205 ) {
19206 panic!(concat!(
19207 "Unable to load ",
19208 stringify!(cmd_decompress_memory_nv)
19209 ))
19210 }
19211 let cname =
19212 CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0");
19213 let val = _f(cname);
19214 if val.is_null() {
19215 cmd_decompress_memory_nv
19216 } else {
19217 ::core::mem::transmute(val)
19218 }
19219 },
19220 cmd_decompress_memory_indirect_count_nv: unsafe {
19221 unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv(
19222 _command_buffer: CommandBuffer,
19223 _indirect_commands_address: DeviceAddress,
19224 _indirect_commands_count_address: DeviceAddress,
19225 _stride: u32,
19226 ) {
19227 panic!(concat!(
19228 "Unable to load ",
19229 stringify!(cmd_decompress_memory_indirect_count_nv)
19230 ))
19231 }
19232 let cname = CStr::from_bytes_with_nul_unchecked(
19233 b"vkCmdDecompressMemoryIndirectCountNV\0",
19234 );
19235 let val = _f(cname);
19236 if val.is_null() {
19237 cmd_decompress_memory_indirect_count_nv
19238 } else {
19239 ::core::mem::transmute(val)
19240 }
19241 },
19242 }
19243 }
19244 }
19245 }
19246 #[doc = "VK_NV_device_generated_commands_compute"]
19247 pub mod device_generated_commands_compute {
19248 use super::super::*;
19249 pub use {
19250 crate::vk::NV_DEVICE_GENERATED_COMMANDS_COMPUTE_NAME as NAME,
19251 crate::vk::NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION as SPEC_VERSION,
19252 };
19253 #[doc = "VK_NV_device_generated_commands_compute device-level functions"]
19254 #[derive(Clone)]
19255 pub struct Device {
19256 pub(crate) fp: DeviceFn,
19257 pub(crate) handle: crate::vk::Device,
19258 }
19259 impl Device {
19260 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19261 let handle = device.handle();
19262 let fp = DeviceFn::load(|name| unsafe {
19263 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19264 });
19265 Self { handle, fp }
19266 }
19267 #[inline]
19268 pub fn fp(&self) -> &DeviceFn {
19269 &self.fp
19270 }
19271 #[inline]
19272 pub fn device(&self) -> crate::vk::Device {
19273 self.handle
19274 }
19275 }
19276 #[derive(Clone)]
19277 #[doc = "Raw VK_NV_device_generated_commands_compute device-level function pointers"]
19278 pub struct DeviceFn {
19279 pub get_pipeline_indirect_memory_requirements_nv:
19280 PFN_vkGetPipelineIndirectMemoryRequirementsNV,
19281 pub cmd_update_pipeline_indirect_buffer_nv: PFN_vkCmdUpdatePipelineIndirectBufferNV,
19282 pub get_pipeline_indirect_device_address_nv: PFN_vkGetPipelineIndirectDeviceAddressNV,
19283 }
19284 unsafe impl Send for DeviceFn {}
19285 unsafe impl Sync for DeviceFn {}
19286 impl DeviceFn {
19287 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19288 Self::load_erased(&mut f)
19289 }
19290 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19291 Self {
19292 get_pipeline_indirect_memory_requirements_nv: unsafe {
19293 unsafe extern "system" fn get_pipeline_indirect_memory_requirements_nv(
19294 _device: crate::vk::Device,
19295 _p_create_info: *const ComputePipelineCreateInfo<'_>,
19296 _p_memory_requirements: *mut MemoryRequirements2<'_>,
19297 ) {
19298 panic!(concat!(
19299 "Unable to load ",
19300 stringify!(get_pipeline_indirect_memory_requirements_nv)
19301 ))
19302 }
19303 let cname = CStr::from_bytes_with_nul_unchecked(
19304 b"vkGetPipelineIndirectMemoryRequirementsNV\0",
19305 );
19306 let val = _f(cname);
19307 if val.is_null() {
19308 get_pipeline_indirect_memory_requirements_nv
19309 } else {
19310 ::core::mem::transmute(val)
19311 }
19312 },
19313 cmd_update_pipeline_indirect_buffer_nv: unsafe {
19314 unsafe extern "system" fn cmd_update_pipeline_indirect_buffer_nv(
19315 _command_buffer: CommandBuffer,
19316 _pipeline_bind_point: PipelineBindPoint,
19317 _pipeline: Pipeline,
19318 ) {
19319 panic!(concat!(
19320 "Unable to load ",
19321 stringify!(cmd_update_pipeline_indirect_buffer_nv)
19322 ))
19323 }
19324 let cname = CStr::from_bytes_with_nul_unchecked(
19325 b"vkCmdUpdatePipelineIndirectBufferNV\0",
19326 );
19327 let val = _f(cname);
19328 if val.is_null() {
19329 cmd_update_pipeline_indirect_buffer_nv
19330 } else {
19331 ::core::mem::transmute(val)
19332 }
19333 },
19334 get_pipeline_indirect_device_address_nv: unsafe {
19335 unsafe extern "system" fn get_pipeline_indirect_device_address_nv(
19336 _device: crate::vk::Device,
19337 _p_info: *const PipelineIndirectDeviceAddressInfoNV<'_>,
19338 ) -> DeviceAddress {
19339 panic!(concat!(
19340 "Unable to load ",
19341 stringify!(get_pipeline_indirect_device_address_nv)
19342 ))
19343 }
19344 let cname = CStr::from_bytes_with_nul_unchecked(
19345 b"vkGetPipelineIndirectDeviceAddressNV\0",
19346 );
19347 let val = _f(cname);
19348 if val.is_null() {
19349 get_pipeline_indirect_device_address_nv
19350 } else {
19351 ::core::mem::transmute(val)
19352 }
19353 },
19354 }
19355 }
19356 }
19357 }
19358 #[doc = "VK_NV_linear_color_attachment"]
19359 pub mod linear_color_attachment {
19360 use super::super::*;
19361 pub use {
19362 crate::vk::NV_LINEAR_COLOR_ATTACHMENT_NAME as NAME,
19363 crate::vk::NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION as SPEC_VERSION,
19364 };
19365 }
19366 #[doc = "VK_NV_optical_flow"]
19367 pub mod optical_flow {
19368 use super::super::*;
19369 pub use {
19370 crate::vk::NV_OPTICAL_FLOW_NAME as NAME,
19371 crate::vk::NV_OPTICAL_FLOW_SPEC_VERSION as SPEC_VERSION,
19372 };
19373 #[doc = "VK_NV_optical_flow instance-level functions"]
19374 #[derive(Clone)]
19375 pub struct Instance {
19376 pub(crate) fp: InstanceFn,
19377 pub(crate) handle: crate::vk::Instance,
19378 }
19379 impl Instance {
19380 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
19381 let handle = instance.handle();
19382 let fp = InstanceFn::load(|name| unsafe {
19383 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
19384 });
19385 Self { handle, fp }
19386 }
19387 #[inline]
19388 pub fn fp(&self) -> &InstanceFn {
19389 &self.fp
19390 }
19391 #[inline]
19392 pub fn instance(&self) -> crate::vk::Instance {
19393 self.handle
19394 }
19395 }
19396 #[derive(Clone)]
19397 #[doc = "Raw VK_NV_optical_flow instance-level function pointers"]
19398 pub struct InstanceFn {
19399 pub get_physical_device_optical_flow_image_formats_nv:
19400 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
19401 }
19402 unsafe impl Send for InstanceFn {}
19403 unsafe impl Sync for InstanceFn {}
19404 impl InstanceFn {
19405 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19406 Self::load_erased(&mut f)
19407 }
19408 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19409 Self {
19410 get_physical_device_optical_flow_image_formats_nv: unsafe {
19411 unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv(
19412 _physical_device: PhysicalDevice,
19413 _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV<
19414 '_,
19415 >,
19416 _p_format_count: *mut u32,
19417 _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV<'_>,
19418 ) -> Result {
19419 panic!(concat!(
19420 "Unable to load ",
19421 stringify!(get_physical_device_optical_flow_image_formats_nv)
19422 ))
19423 }
19424 let cname = CStr::from_bytes_with_nul_unchecked(
19425 b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0",
19426 );
19427 let val = _f(cname);
19428 if val.is_null() {
19429 get_physical_device_optical_flow_image_formats_nv
19430 } else {
19431 ::core::mem::transmute(val)
19432 }
19433 },
19434 }
19435 }
19436 }
19437 #[doc = "VK_NV_optical_flow device-level functions"]
19438 #[derive(Clone)]
19439 pub struct Device {
19440 pub(crate) fp: DeviceFn,
19441 pub(crate) handle: crate::vk::Device,
19442 }
19443 impl Device {
19444 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19445 let handle = device.handle();
19446 let fp = DeviceFn::load(|name| unsafe {
19447 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19448 });
19449 Self { handle, fp }
19450 }
19451 #[inline]
19452 pub fn fp(&self) -> &DeviceFn {
19453 &self.fp
19454 }
19455 #[inline]
19456 pub fn device(&self) -> crate::vk::Device {
19457 self.handle
19458 }
19459 }
19460 #[derive(Clone)]
19461 #[doc = "Raw VK_NV_optical_flow device-level function pointers"]
19462 pub struct DeviceFn {
19463 pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV,
19464 pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV,
19465 pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV,
19466 pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV,
19467 }
19468 unsafe impl Send for DeviceFn {}
19469 unsafe impl Sync for DeviceFn {}
19470 impl DeviceFn {
19471 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19472 Self::load_erased(&mut f)
19473 }
19474 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19475 Self {
19476 create_optical_flow_session_nv: unsafe {
19477 unsafe extern "system" fn create_optical_flow_session_nv(
19478 _device: crate::vk::Device,
19479 _p_create_info: *const OpticalFlowSessionCreateInfoNV<'_>,
19480 _p_allocator: *const AllocationCallbacks<'_>,
19481 _p_session: *mut OpticalFlowSessionNV,
19482 ) -> Result {
19483 panic!(concat!(
19484 "Unable to load ",
19485 stringify!(create_optical_flow_session_nv)
19486 ))
19487 }
19488 let cname =
19489 CStr::from_bytes_with_nul_unchecked(b"vkCreateOpticalFlowSessionNV\0");
19490 let val = _f(cname);
19491 if val.is_null() {
19492 create_optical_flow_session_nv
19493 } else {
19494 ::core::mem::transmute(val)
19495 }
19496 },
19497 destroy_optical_flow_session_nv: unsafe {
19498 unsafe extern "system" fn destroy_optical_flow_session_nv(
19499 _device: crate::vk::Device,
19500 _session: OpticalFlowSessionNV,
19501 _p_allocator: *const AllocationCallbacks<'_>,
19502 ) {
19503 panic!(concat!(
19504 "Unable to load ",
19505 stringify!(destroy_optical_flow_session_nv)
19506 ))
19507 }
19508 let cname =
19509 CStr::from_bytes_with_nul_unchecked(b"vkDestroyOpticalFlowSessionNV\0");
19510 let val = _f(cname);
19511 if val.is_null() {
19512 destroy_optical_flow_session_nv
19513 } else {
19514 ::core::mem::transmute(val)
19515 }
19516 },
19517 bind_optical_flow_session_image_nv: unsafe {
19518 unsafe extern "system" fn bind_optical_flow_session_image_nv(
19519 _device: crate::vk::Device,
19520 _session: OpticalFlowSessionNV,
19521 _binding_point: OpticalFlowSessionBindingPointNV,
19522 _view: ImageView,
19523 _layout: ImageLayout,
19524 ) -> Result {
19525 panic!(concat!(
19526 "Unable to load ",
19527 stringify!(bind_optical_flow_session_image_nv)
19528 ))
19529 }
19530 let cname = CStr::from_bytes_with_nul_unchecked(
19531 b"vkBindOpticalFlowSessionImageNV\0",
19532 );
19533 let val = _f(cname);
19534 if val.is_null() {
19535 bind_optical_flow_session_image_nv
19536 } else {
19537 ::core::mem::transmute(val)
19538 }
19539 },
19540 cmd_optical_flow_execute_nv: unsafe {
19541 unsafe extern "system" fn cmd_optical_flow_execute_nv(
19542 _command_buffer: CommandBuffer,
19543 _session: OpticalFlowSessionNV,
19544 _p_execute_info: *const OpticalFlowExecuteInfoNV<'_>,
19545 ) {
19546 panic!(concat!(
19547 "Unable to load ",
19548 stringify!(cmd_optical_flow_execute_nv)
19549 ))
19550 }
19551 let cname =
19552 CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0");
19553 let val = _f(cname);
19554 if val.is_null() {
19555 cmd_optical_flow_execute_nv
19556 } else {
19557 ::core::mem::transmute(val)
19558 }
19559 },
19560 }
19561 }
19562 }
19563 }
19564 #[doc = "VK_NV_ray_tracing_invocation_reorder"]
19565 pub mod ray_tracing_invocation_reorder {
19566 use super::super::*;
19567 pub use {
19568 crate::vk::NV_RAY_TRACING_INVOCATION_REORDER_NAME as NAME,
19569 crate::vk::NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION as SPEC_VERSION,
19570 };
19571 }
19572 #[doc = "VK_NV_extended_sparse_address_space"]
19573 pub mod extended_sparse_address_space {
19574 use super::super::*;
19575 pub use {
19576 crate::vk::NV_EXTENDED_SPARSE_ADDRESS_SPACE_NAME as NAME,
19577 crate::vk::NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION as SPEC_VERSION,
19578 };
19579 }
19580 #[doc = "VK_NV_low_latency2"]
19581 pub mod low_latency2 {
19582 use super::super::*;
19583 pub use {
19584 crate::vk::NV_LOW_LATENCY2_NAME as NAME,
19585 crate::vk::NV_LOW_LATENCY2_SPEC_VERSION as SPEC_VERSION,
19586 };
19587 #[doc = "VK_NV_low_latency2 device-level functions"]
19588 #[derive(Clone)]
19589 pub struct Device {
19590 pub(crate) fp: DeviceFn,
19591 pub(crate) handle: crate::vk::Device,
19592 }
19593 impl Device {
19594 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19595 let handle = device.handle();
19596 let fp = DeviceFn::load(|name| unsafe {
19597 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19598 });
19599 Self { handle, fp }
19600 }
19601 #[inline]
19602 pub fn fp(&self) -> &DeviceFn {
19603 &self.fp
19604 }
19605 #[inline]
19606 pub fn device(&self) -> crate::vk::Device {
19607 self.handle
19608 }
19609 }
19610 #[derive(Clone)]
19611 #[doc = "Raw VK_NV_low_latency2 device-level function pointers"]
19612 pub struct DeviceFn {
19613 pub set_latency_sleep_mode_nv: PFN_vkSetLatencySleepModeNV,
19614 pub latency_sleep_nv: PFN_vkLatencySleepNV,
19615 pub set_latency_marker_nv: PFN_vkSetLatencyMarkerNV,
19616 pub get_latency_timings_nv: PFN_vkGetLatencyTimingsNV,
19617 pub queue_notify_out_of_band_nv: PFN_vkQueueNotifyOutOfBandNV,
19618 }
19619 unsafe impl Send for DeviceFn {}
19620 unsafe impl Sync for DeviceFn {}
19621 impl DeviceFn {
19622 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19623 Self::load_erased(&mut f)
19624 }
19625 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19626 Self {
19627 set_latency_sleep_mode_nv: unsafe {
19628 unsafe extern "system" fn set_latency_sleep_mode_nv(
19629 _device: crate::vk::Device,
19630 _swapchain: SwapchainKHR,
19631 _p_sleep_mode_info: *const LatencySleepModeInfoNV<'_>,
19632 ) -> Result {
19633 panic!(concat!(
19634 "Unable to load ",
19635 stringify!(set_latency_sleep_mode_nv)
19636 ))
19637 }
19638 let cname =
19639 CStr::from_bytes_with_nul_unchecked(b"vkSetLatencySleepModeNV\0");
19640 let val = _f(cname);
19641 if val.is_null() {
19642 set_latency_sleep_mode_nv
19643 } else {
19644 ::core::mem::transmute(val)
19645 }
19646 },
19647 latency_sleep_nv: unsafe {
19648 unsafe extern "system" fn latency_sleep_nv(
19649 _device: crate::vk::Device,
19650 _swapchain: SwapchainKHR,
19651 _p_sleep_info: *const LatencySleepInfoNV<'_>,
19652 ) -> Result {
19653 panic!(concat!("Unable to load ", stringify!(latency_sleep_nv)))
19654 }
19655 let cname = CStr::from_bytes_with_nul_unchecked(b"vkLatencySleepNV\0");
19656 let val = _f(cname);
19657 if val.is_null() {
19658 latency_sleep_nv
19659 } else {
19660 ::core::mem::transmute(val)
19661 }
19662 },
19663 set_latency_marker_nv: unsafe {
19664 unsafe extern "system" fn set_latency_marker_nv(
19665 _device: crate::vk::Device,
19666 _swapchain: SwapchainKHR,
19667 _p_latency_marker_info: *const SetLatencyMarkerInfoNV<'_>,
19668 ) {
19669 panic!(concat!(
19670 "Unable to load ",
19671 stringify!(set_latency_marker_nv)
19672 ))
19673 }
19674 let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetLatencyMarkerNV\0");
19675 let val = _f(cname);
19676 if val.is_null() {
19677 set_latency_marker_nv
19678 } else {
19679 ::core::mem::transmute(val)
19680 }
19681 },
19682 get_latency_timings_nv: unsafe {
19683 unsafe extern "system" fn get_latency_timings_nv(
19684 _device: crate::vk::Device,
19685 _swapchain: SwapchainKHR,
19686 _p_latency_marker_info: *mut GetLatencyMarkerInfoNV<'_>,
19687 ) {
19688 panic!(concat!(
19689 "Unable to load ",
19690 stringify!(get_latency_timings_nv)
19691 ))
19692 }
19693 let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetLatencyTimingsNV\0");
19694 let val = _f(cname);
19695 if val.is_null() {
19696 get_latency_timings_nv
19697 } else {
19698 ::core::mem::transmute(val)
19699 }
19700 },
19701 queue_notify_out_of_band_nv: unsafe {
19702 unsafe extern "system" fn queue_notify_out_of_band_nv(
19703 _queue: Queue,
19704 _p_queue_type_info: *const OutOfBandQueueTypeInfoNV<'_>,
19705 ) {
19706 panic!(concat!(
19707 "Unable to load ",
19708 stringify!(queue_notify_out_of_band_nv)
19709 ))
19710 }
19711 let cname =
19712 CStr::from_bytes_with_nul_unchecked(b"vkQueueNotifyOutOfBandNV\0");
19713 let val = _f(cname);
19714 if val.is_null() {
19715 queue_notify_out_of_band_nv
19716 } else {
19717 ::core::mem::transmute(val)
19718 }
19719 },
19720 }
19721 }
19722 }
19723 }
19724 #[doc = "VK_NV_per_stage_descriptor_set"]
19725 pub mod per_stage_descriptor_set {
19726 use super::super::*;
19727 pub use {
19728 crate::vk::NV_PER_STAGE_DESCRIPTOR_SET_NAME as NAME,
19729 crate::vk::NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION as SPEC_VERSION,
19730 };
19731 }
19732 #[doc = "VK_NV_descriptor_pool_overallocation"]
19733 pub mod descriptor_pool_overallocation {
19734 use super::super::*;
19735 pub use {
19736 crate::vk::NV_DESCRIPTOR_POOL_OVERALLOCATION_NAME as NAME,
19737 crate::vk::NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION as SPEC_VERSION,
19738 };
19739 }
19740 #[doc = "VK_NV_raw_access_chains"]
19741 pub mod raw_access_chains {
19742 use super::super::*;
19743 pub use {
19744 crate::vk::NV_RAW_ACCESS_CHAINS_NAME as NAME,
19745 crate::vk::NV_RAW_ACCESS_CHAINS_SPEC_VERSION as SPEC_VERSION,
19746 };
19747 }
19748 #[doc = "VK_NV_shader_atomic_float16_vector"]
19749 pub mod shader_atomic_float16_vector {
19750 use super::super::*;
19751 pub use {
19752 crate::vk::NV_SHADER_ATOMIC_FLOAT16_VECTOR_NAME as NAME,
19753 crate::vk::NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION as SPEC_VERSION,
19754 };
19755 }
19756 #[doc = "VK_NV_ray_tracing_validation"]
19757 pub mod ray_tracing_validation {
19758 use super::super::*;
19759 pub use {
19760 crate::vk::NV_RAY_TRACING_VALIDATION_NAME as NAME,
19761 crate::vk::NV_RAY_TRACING_VALIDATION_SPEC_VERSION as SPEC_VERSION,
19762 };
19763 }
19764}
19765#[doc = "Extensions tagged NVX"]
19766pub mod nvx {
19767 #[doc = "VK_NVX_binary_import"]
19768 pub mod binary_import {
19769 use super::super::*;
19770 pub use {
19771 crate::vk::NVX_BINARY_IMPORT_NAME as NAME,
19772 crate::vk::NVX_BINARY_IMPORT_SPEC_VERSION as SPEC_VERSION,
19773 };
19774 #[doc = "VK_NVX_binary_import device-level functions"]
19775 #[derive(Clone)]
19776 pub struct Device {
19777 pub(crate) fp: DeviceFn,
19778 pub(crate) handle: crate::vk::Device,
19779 }
19780 impl Device {
19781 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19782 let handle = device.handle();
19783 let fp = DeviceFn::load(|name| unsafe {
19784 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19785 });
19786 Self { handle, fp }
19787 }
19788 #[inline]
19789 pub fn fp(&self) -> &DeviceFn {
19790 &self.fp
19791 }
19792 #[inline]
19793 pub fn device(&self) -> crate::vk::Device {
19794 self.handle
19795 }
19796 }
19797 #[derive(Clone)]
19798 #[doc = "Raw VK_NVX_binary_import device-level function pointers"]
19799 pub struct DeviceFn {
19800 pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX,
19801 pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX,
19802 pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX,
19803 pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX,
19804 pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX,
19805 }
19806 unsafe impl Send for DeviceFn {}
19807 unsafe impl Sync for DeviceFn {}
19808 impl DeviceFn {
19809 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19810 Self::load_erased(&mut f)
19811 }
19812 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19813 Self {
19814 create_cu_module_nvx: unsafe {
19815 unsafe extern "system" fn create_cu_module_nvx(
19816 _device: crate::vk::Device,
19817 _p_create_info: *const CuModuleCreateInfoNVX<'_>,
19818 _p_allocator: *const AllocationCallbacks<'_>,
19819 _p_module: *mut CuModuleNVX,
19820 ) -> Result {
19821 panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx)))
19822 }
19823 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0");
19824 let val = _f(cname);
19825 if val.is_null() {
19826 create_cu_module_nvx
19827 } else {
19828 ::core::mem::transmute(val)
19829 }
19830 },
19831 create_cu_function_nvx: unsafe {
19832 unsafe extern "system" fn create_cu_function_nvx(
19833 _device: crate::vk::Device,
19834 _p_create_info: *const CuFunctionCreateInfoNVX<'_>,
19835 _p_allocator: *const AllocationCallbacks<'_>,
19836 _p_function: *mut CuFunctionNVX,
19837 ) -> Result {
19838 panic!(concat!(
19839 "Unable to load ",
19840 stringify!(create_cu_function_nvx)
19841 ))
19842 }
19843 let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0");
19844 let val = _f(cname);
19845 if val.is_null() {
19846 create_cu_function_nvx
19847 } else {
19848 ::core::mem::transmute(val)
19849 }
19850 },
19851 destroy_cu_module_nvx: unsafe {
19852 unsafe extern "system" fn destroy_cu_module_nvx(
19853 _device: crate::vk::Device,
19854 _module: CuModuleNVX,
19855 _p_allocator: *const AllocationCallbacks<'_>,
19856 ) {
19857 panic!(concat!(
19858 "Unable to load ",
19859 stringify!(destroy_cu_module_nvx)
19860 ))
19861 }
19862 let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0");
19863 let val = _f(cname);
19864 if val.is_null() {
19865 destroy_cu_module_nvx
19866 } else {
19867 ::core::mem::transmute(val)
19868 }
19869 },
19870 destroy_cu_function_nvx: unsafe {
19871 unsafe extern "system" fn destroy_cu_function_nvx(
19872 _device: crate::vk::Device,
19873 _function: CuFunctionNVX,
19874 _p_allocator: *const AllocationCallbacks<'_>,
19875 ) {
19876 panic!(concat!(
19877 "Unable to load ",
19878 stringify!(destroy_cu_function_nvx)
19879 ))
19880 }
19881 let cname =
19882 CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0");
19883 let val = _f(cname);
19884 if val.is_null() {
19885 destroy_cu_function_nvx
19886 } else {
19887 ::core::mem::transmute(val)
19888 }
19889 },
19890 cmd_cu_launch_kernel_nvx: unsafe {
19891 unsafe extern "system" fn cmd_cu_launch_kernel_nvx(
19892 _command_buffer: CommandBuffer,
19893 _p_launch_info: *const CuLaunchInfoNVX<'_>,
19894 ) {
19895 panic!(concat!(
19896 "Unable to load ",
19897 stringify!(cmd_cu_launch_kernel_nvx)
19898 ))
19899 }
19900 let cname =
19901 CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0");
19902 let val = _f(cname);
19903 if val.is_null() {
19904 cmd_cu_launch_kernel_nvx
19905 } else {
19906 ::core::mem::transmute(val)
19907 }
19908 },
19909 }
19910 }
19911 }
19912 }
19913 #[doc = "VK_NVX_image_view_handle"]
19914 pub mod image_view_handle {
19915 use super::super::*;
19916 pub use {
19917 crate::vk::NVX_IMAGE_VIEW_HANDLE_NAME as NAME,
19918 crate::vk::NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION as SPEC_VERSION,
19919 };
19920 #[doc = "VK_NVX_image_view_handle device-level functions"]
19921 #[derive(Clone)]
19922 pub struct Device {
19923 pub(crate) fp: DeviceFn,
19924 pub(crate) handle: crate::vk::Device,
19925 }
19926 impl Device {
19927 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
19928 let handle = device.handle();
19929 let fp = DeviceFn::load(|name| unsafe {
19930 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19931 });
19932 Self { handle, fp }
19933 }
19934 #[inline]
19935 pub fn fp(&self) -> &DeviceFn {
19936 &self.fp
19937 }
19938 #[inline]
19939 pub fn device(&self) -> crate::vk::Device {
19940 self.handle
19941 }
19942 }
19943 #[derive(Clone)]
19944 #[doc = "Raw VK_NVX_image_view_handle device-level function pointers"]
19945 pub struct DeviceFn {
19946 pub get_image_view_handle_nvx: PFN_vkGetImageViewHandleNVX,
19947 pub get_image_view_address_nvx: PFN_vkGetImageViewAddressNVX,
19948 }
19949 unsafe impl Send for DeviceFn {}
19950 unsafe impl Sync for DeviceFn {}
19951 impl DeviceFn {
19952 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
19953 Self::load_erased(&mut f)
19954 }
19955 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
19956 Self {
19957 get_image_view_handle_nvx: unsafe {
19958 unsafe extern "system" fn get_image_view_handle_nvx(
19959 _device: crate::vk::Device,
19960 _p_info: *const ImageViewHandleInfoNVX<'_>,
19961 ) -> u32 {
19962 panic!(concat!(
19963 "Unable to load ",
19964 stringify!(get_image_view_handle_nvx)
19965 ))
19966 }
19967 let cname =
19968 CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewHandleNVX\0");
19969 let val = _f(cname);
19970 if val.is_null() {
19971 get_image_view_handle_nvx
19972 } else {
19973 ::core::mem::transmute(val)
19974 }
19975 },
19976 get_image_view_address_nvx: unsafe {
19977 unsafe extern "system" fn get_image_view_address_nvx(
19978 _device: crate::vk::Device,
19979 _image_view: ImageView,
19980 _p_properties: *mut ImageViewAddressPropertiesNVX<'_>,
19981 ) -> Result {
19982 panic!(concat!(
19983 "Unable to load ",
19984 stringify!(get_image_view_address_nvx)
19985 ))
19986 }
19987 let cname =
19988 CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewAddressNVX\0");
19989 let val = _f(cname);
19990 if val.is_null() {
19991 get_image_view_address_nvx
19992 } else {
19993 ::core::mem::transmute(val)
19994 }
19995 },
19996 }
19997 }
19998 }
19999 }
20000 #[doc = "VK_NVX_multiview_per_view_attributes"]
20001 pub mod multiview_per_view_attributes {
20002 use super::super::*;
20003 pub use {
20004 crate::vk::NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_NAME as NAME,
20005 crate::vk::NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION as SPEC_VERSION,
20006 };
20007 }
20008}
20009#[doc = "Extensions tagged QCOM"]
20010pub mod qcom {
20011 #[doc = "VK_QCOM_render_pass_shader_resolve"]
20012 pub mod render_pass_shader_resolve {
20013 use super::super::*;
20014 pub use {
20015 crate::vk::QCOM_RENDER_PASS_SHADER_RESOLVE_NAME as NAME,
20016 crate::vk::QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION as SPEC_VERSION,
20017 };
20018 }
20019 #[doc = "VK_QCOM_render_pass_transform"]
20020 pub mod render_pass_transform {
20021 use super::super::*;
20022 pub use {
20023 crate::vk::QCOM_RENDER_PASS_TRANSFORM_NAME as NAME,
20024 crate::vk::QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION as SPEC_VERSION,
20025 };
20026 }
20027 #[doc = "VK_QCOM_render_pass_store_ops"]
20028 pub mod render_pass_store_ops {
20029 use super::super::*;
20030 pub use {
20031 crate::vk::QCOM_RENDER_PASS_STORE_OPS_NAME as NAME,
20032 crate::vk::QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION as SPEC_VERSION,
20033 };
20034 }
20035 #[doc = "VK_QCOM_rotated_copy_commands"]
20036 pub mod rotated_copy_commands {
20037 use super::super::*;
20038 pub use {
20039 crate::vk::QCOM_ROTATED_COPY_COMMANDS_NAME as NAME,
20040 crate::vk::QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION as SPEC_VERSION,
20041 };
20042 }
20043 #[doc = "VK_QCOM_fragment_density_map_offset"]
20044 pub mod fragment_density_map_offset {
20045 use super::super::*;
20046 pub use {
20047 crate::vk::QCOM_FRAGMENT_DENSITY_MAP_OFFSET_NAME as NAME,
20048 crate::vk::QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION as SPEC_VERSION,
20049 };
20050 }
20051 #[doc = "VK_QCOM_image_processing"]
20052 pub mod image_processing {
20053 use super::super::*;
20054 pub use {
20055 crate::vk::QCOM_IMAGE_PROCESSING_NAME as NAME,
20056 crate::vk::QCOM_IMAGE_PROCESSING_SPEC_VERSION as SPEC_VERSION,
20057 };
20058 }
20059 #[doc = "VK_QCOM_tile_properties"]
20060 pub mod tile_properties {
20061 use super::super::*;
20062 pub use {
20063 crate::vk::QCOM_TILE_PROPERTIES_NAME as NAME,
20064 crate::vk::QCOM_TILE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
20065 };
20066 #[doc = "VK_QCOM_tile_properties device-level functions"]
20067 #[derive(Clone)]
20068 pub struct Device {
20069 pub(crate) fp: DeviceFn,
20070 pub(crate) handle: crate::vk::Device,
20071 }
20072 impl Device {
20073 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
20074 let handle = device.handle();
20075 let fp = DeviceFn::load(|name| unsafe {
20076 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
20077 });
20078 Self { handle, fp }
20079 }
20080 #[inline]
20081 pub fn fp(&self) -> &DeviceFn {
20082 &self.fp
20083 }
20084 #[inline]
20085 pub fn device(&self) -> crate::vk::Device {
20086 self.handle
20087 }
20088 }
20089 #[derive(Clone)]
20090 #[doc = "Raw VK_QCOM_tile_properties device-level function pointers"]
20091 pub struct DeviceFn {
20092 pub get_framebuffer_tile_properties_qcom: PFN_vkGetFramebufferTilePropertiesQCOM,
20093 pub get_dynamic_rendering_tile_properties_qcom:
20094 PFN_vkGetDynamicRenderingTilePropertiesQCOM,
20095 }
20096 unsafe impl Send for DeviceFn {}
20097 unsafe impl Sync for DeviceFn {}
20098 impl DeviceFn {
20099 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
20100 Self::load_erased(&mut f)
20101 }
20102 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
20103 Self {
20104 get_framebuffer_tile_properties_qcom: unsafe {
20105 unsafe extern "system" fn get_framebuffer_tile_properties_qcom(
20106 _device: crate::vk::Device,
20107 _framebuffer: Framebuffer,
20108 _p_properties_count: *mut u32,
20109 _p_properties: *mut TilePropertiesQCOM<'_>,
20110 ) -> Result {
20111 panic!(concat!(
20112 "Unable to load ",
20113 stringify!(get_framebuffer_tile_properties_qcom)
20114 ))
20115 }
20116 let cname = CStr::from_bytes_with_nul_unchecked(
20117 b"vkGetFramebufferTilePropertiesQCOM\0",
20118 );
20119 let val = _f(cname);
20120 if val.is_null() {
20121 get_framebuffer_tile_properties_qcom
20122 } else {
20123 ::core::mem::transmute(val)
20124 }
20125 },
20126 get_dynamic_rendering_tile_properties_qcom: unsafe {
20127 unsafe extern "system" fn get_dynamic_rendering_tile_properties_qcom(
20128 _device: crate::vk::Device,
20129 _p_rendering_info: *const RenderingInfo<'_>,
20130 _p_properties: *mut TilePropertiesQCOM<'_>,
20131 ) -> Result {
20132 panic!(concat!(
20133 "Unable to load ",
20134 stringify!(get_dynamic_rendering_tile_properties_qcom)
20135 ))
20136 }
20137 let cname = CStr::from_bytes_with_nul_unchecked(
20138 b"vkGetDynamicRenderingTilePropertiesQCOM\0",
20139 );
20140 let val = _f(cname);
20141 if val.is_null() {
20142 get_dynamic_rendering_tile_properties_qcom
20143 } else {
20144 ::core::mem::transmute(val)
20145 }
20146 },
20147 }
20148 }
20149 }
20150 }
20151 #[doc = "VK_QCOM_multiview_per_view_viewports"]
20152 pub mod multiview_per_view_viewports {
20153 use super::super::*;
20154 pub use {
20155 crate::vk::QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_NAME as NAME,
20156 crate::vk::QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION as SPEC_VERSION,
20157 };
20158 }
20159 #[doc = "VK_QCOM_multiview_per_view_render_areas"]
20160 pub mod multiview_per_view_render_areas {
20161 use super::super::*;
20162 pub use {
20163 crate::vk::QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_NAME as NAME,
20164 crate::vk::QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION as SPEC_VERSION,
20165 };
20166 }
20167 #[doc = "VK_QCOM_image_processing2"]
20168 pub mod image_processing2 {
20169 use super::super::*;
20170 pub use {
20171 crate::vk::QCOM_IMAGE_PROCESSING2_NAME as NAME,
20172 crate::vk::QCOM_IMAGE_PROCESSING2_SPEC_VERSION as SPEC_VERSION,
20173 };
20174 }
20175 #[doc = "VK_QCOM_filter_cubic_weights"]
20176 pub mod filter_cubic_weights {
20177 use super::super::*;
20178 pub use {
20179 crate::vk::QCOM_FILTER_CUBIC_WEIGHTS_NAME as NAME,
20180 crate::vk::QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION as SPEC_VERSION,
20181 };
20182 }
20183 #[doc = "VK_QCOM_ycbcr_degamma"]
20184 pub mod ycbcr_degamma {
20185 use super::super::*;
20186 pub use {
20187 crate::vk::QCOM_YCBCR_DEGAMMA_NAME as NAME,
20188 crate::vk::QCOM_YCBCR_DEGAMMA_SPEC_VERSION as SPEC_VERSION,
20189 };
20190 }
20191 #[doc = "VK_QCOM_filter_cubic_clamp"]
20192 pub mod filter_cubic_clamp {
20193 use super::super::*;
20194 pub use {
20195 crate::vk::QCOM_FILTER_CUBIC_CLAMP_NAME as NAME,
20196 crate::vk::QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION as SPEC_VERSION,
20197 };
20198 }
20199}
20200#[doc = "Extensions tagged QNX"]
20201pub mod qnx {
20202 #[doc = "VK_QNX_screen_surface"]
20203 pub mod screen_surface {
20204 use super::super::*;
20205 pub use {
20206 crate::vk::QNX_SCREEN_SURFACE_NAME as NAME,
20207 crate::vk::QNX_SCREEN_SURFACE_SPEC_VERSION as SPEC_VERSION,
20208 };
20209 #[doc = "VK_QNX_screen_surface instance-level functions"]
20210 #[derive(Clone)]
20211 pub struct Instance {
20212 pub(crate) fp: InstanceFn,
20213 pub(crate) handle: crate::vk::Instance,
20214 }
20215 impl Instance {
20216 pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
20217 let handle = instance.handle();
20218 let fp = InstanceFn::load(|name| unsafe {
20219 core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
20220 });
20221 Self { handle, fp }
20222 }
20223 #[inline]
20224 pub fn fp(&self) -> &InstanceFn {
20225 &self.fp
20226 }
20227 #[inline]
20228 pub fn instance(&self) -> crate::vk::Instance {
20229 self.handle
20230 }
20231 }
20232 #[derive(Clone)]
20233 #[doc = "Raw VK_QNX_screen_surface instance-level function pointers"]
20234 pub struct InstanceFn {
20235 pub create_screen_surface_qnx: PFN_vkCreateScreenSurfaceQNX,
20236 pub get_physical_device_screen_presentation_support_qnx:
20237 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX,
20238 }
20239 unsafe impl Send for InstanceFn {}
20240 unsafe impl Sync for InstanceFn {}
20241 impl InstanceFn {
20242 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
20243 Self::load_erased(&mut f)
20244 }
20245 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
20246 Self {
20247 create_screen_surface_qnx: unsafe {
20248 unsafe extern "system" fn create_screen_surface_qnx(
20249 _instance: crate::vk::Instance,
20250 _p_create_info: *const ScreenSurfaceCreateInfoQNX<'_>,
20251 _p_allocator: *const AllocationCallbacks<'_>,
20252 _p_surface: *mut SurfaceKHR,
20253 ) -> Result {
20254 panic!(concat!(
20255 "Unable to load ",
20256 stringify!(create_screen_surface_qnx)
20257 ))
20258 }
20259 let cname =
20260 CStr::from_bytes_with_nul_unchecked(b"vkCreateScreenSurfaceQNX\0");
20261 let val = _f(cname);
20262 if val.is_null() {
20263 create_screen_surface_qnx
20264 } else {
20265 ::core::mem::transmute(val)
20266 }
20267 },
20268 get_physical_device_screen_presentation_support_qnx: unsafe {
20269 unsafe extern "system" fn get_physical_device_screen_presentation_support_qnx(
20270 _physical_device: PhysicalDevice,
20271 _queue_family_index: u32,
20272 _window: *mut _screen_window,
20273 ) -> Bool32 {
20274 panic!(concat!(
20275 "Unable to load ",
20276 stringify!(get_physical_device_screen_presentation_support_qnx)
20277 ))
20278 }
20279 let cname = CStr::from_bytes_with_nul_unchecked(
20280 b"vkGetPhysicalDeviceScreenPresentationSupportQNX\0",
20281 );
20282 let val = _f(cname);
20283 if val.is_null() {
20284 get_physical_device_screen_presentation_support_qnx
20285 } else {
20286 ::core::mem::transmute(val)
20287 }
20288 },
20289 }
20290 }
20291 }
20292 }
20293 #[doc = "VK_QNX_external_memory_screen_buffer"]
20294 pub mod external_memory_screen_buffer {
20295 use super::super::*;
20296 pub use {
20297 crate::vk::QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_NAME as NAME,
20298 crate::vk::QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION as SPEC_VERSION,
20299 };
20300 #[doc = "VK_QNX_external_memory_screen_buffer device-level functions"]
20301 #[derive(Clone)]
20302 pub struct Device {
20303 pub(crate) fp: DeviceFn,
20304 pub(crate) handle: crate::vk::Device,
20305 }
20306 impl Device {
20307 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
20308 let handle = device.handle();
20309 let fp = DeviceFn::load(|name| unsafe {
20310 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
20311 });
20312 Self { handle, fp }
20313 }
20314 #[inline]
20315 pub fn fp(&self) -> &DeviceFn {
20316 &self.fp
20317 }
20318 #[inline]
20319 pub fn device(&self) -> crate::vk::Device {
20320 self.handle
20321 }
20322 }
20323 #[derive(Clone)]
20324 #[doc = "Raw VK_QNX_external_memory_screen_buffer device-level function pointers"]
20325 pub struct DeviceFn {
20326 pub get_screen_buffer_properties_qnx: PFN_vkGetScreenBufferPropertiesQNX,
20327 }
20328 unsafe impl Send for DeviceFn {}
20329 unsafe impl Sync for DeviceFn {}
20330 impl DeviceFn {
20331 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
20332 Self::load_erased(&mut f)
20333 }
20334 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
20335 Self {
20336 get_screen_buffer_properties_qnx: unsafe {
20337 unsafe extern "system" fn get_screen_buffer_properties_qnx(
20338 _device: crate::vk::Device,
20339 _buffer: *const _screen_buffer,
20340 _p_properties: *mut ScreenBufferPropertiesQNX<'_>,
20341 ) -> Result {
20342 panic!(concat!(
20343 "Unable to load ",
20344 stringify!(get_screen_buffer_properties_qnx)
20345 ))
20346 }
20347 let cname = CStr::from_bytes_with_nul_unchecked(
20348 b"vkGetScreenBufferPropertiesQNX\0",
20349 );
20350 let val = _f(cname);
20351 if val.is_null() {
20352 get_screen_buffer_properties_qnx
20353 } else {
20354 ::core::mem::transmute(val)
20355 }
20356 },
20357 }
20358 }
20359 }
20360 }
20361}
20362#[doc = "Extensions tagged SEC"]
20363pub mod sec {
20364 #[doc = "VK_SEC_amigo_profiling"]
20365 pub mod amigo_profiling {
20366 use super::super::*;
20367 pub use {
20368 crate::vk::SEC_AMIGO_PROFILING_NAME as NAME,
20369 crate::vk::SEC_AMIGO_PROFILING_SPEC_VERSION as SPEC_VERSION,
20370 };
20371 }
20372}
20373#[doc = "Extensions tagged VALVE"]
20374pub mod valve {
20375 #[doc = "VK_VALVE_mutable_descriptor_type"]
20376 pub mod mutable_descriptor_type {
20377 use super::super::*;
20378 pub use {
20379 crate::vk::VALVE_MUTABLE_DESCRIPTOR_TYPE_NAME as NAME,
20380 crate::vk::VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION as SPEC_VERSION,
20381 };
20382 }
20383 #[doc = "VK_VALVE_descriptor_set_host_mapping"]
20384 pub mod descriptor_set_host_mapping {
20385 use super::super::*;
20386 pub use {
20387 crate::vk::VALVE_DESCRIPTOR_SET_HOST_MAPPING_NAME as NAME,
20388 crate::vk::VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION as SPEC_VERSION,
20389 };
20390 #[doc = "VK_VALVE_descriptor_set_host_mapping device-level functions"]
20391 #[derive(Clone)]
20392 pub struct Device {
20393 pub(crate) fp: DeviceFn,
20394 pub(crate) handle: crate::vk::Device,
20395 }
20396 impl Device {
20397 pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
20398 let handle = device.handle();
20399 let fp = DeviceFn::load(|name| unsafe {
20400 core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
20401 });
20402 Self { handle, fp }
20403 }
20404 #[inline]
20405 pub fn fp(&self) -> &DeviceFn {
20406 &self.fp
20407 }
20408 #[inline]
20409 pub fn device(&self) -> crate::vk::Device {
20410 self.handle
20411 }
20412 }
20413 #[derive(Clone)]
20414 #[doc = "Raw VK_VALVE_descriptor_set_host_mapping device-level function pointers"]
20415 pub struct DeviceFn {
20416 pub get_descriptor_set_layout_host_mapping_info_valve:
20417 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
20418 pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE,
20419 }
20420 unsafe impl Send for DeviceFn {}
20421 unsafe impl Sync for DeviceFn {}
20422 impl DeviceFn {
20423 pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
20424 Self::load_erased(&mut f)
20425 }
20426 fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
20427 Self {
20428 get_descriptor_set_layout_host_mapping_info_valve: unsafe {
20429 unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve(
20430 _device: crate::vk::Device,
20431 _p_binding_reference: *const DescriptorSetBindingReferenceVALVE<'_>,
20432 _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE<'_>,
20433 ) {
20434 panic!(concat!(
20435 "Unable to load ",
20436 stringify!(get_descriptor_set_layout_host_mapping_info_valve)
20437 ))
20438 }
20439 let cname = CStr::from_bytes_with_nul_unchecked(
20440 b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0",
20441 );
20442 let val = _f(cname);
20443 if val.is_null() {
20444 get_descriptor_set_layout_host_mapping_info_valve
20445 } else {
20446 ::core::mem::transmute(val)
20447 }
20448 },
20449 get_descriptor_set_host_mapping_valve: unsafe {
20450 unsafe extern "system" fn get_descriptor_set_host_mapping_valve(
20451 _device: crate::vk::Device,
20452 _descriptor_set: DescriptorSet,
20453 _pp_data: *mut *mut c_void,
20454 ) {
20455 panic!(concat!(
20456 "Unable to load ",
20457 stringify!(get_descriptor_set_host_mapping_valve)
20458 ))
20459 }
20460 let cname = CStr::from_bytes_with_nul_unchecked(
20461 b"vkGetDescriptorSetHostMappingVALVE\0",
20462 );
20463 let val = _f(cname);
20464 if val.is_null() {
20465 get_descriptor_set_host_mapping_valve
20466 } else {
20467 ::core::mem::transmute(val)
20468 }
20469 },
20470 }
20471 }
20472 }
20473 }
20474}